Beginner Friendly ASP NET Core Web API Tutorial W3Schools Guide

Looking for a comprehensive guide to creating a Web API with ASP.NET Core? You've come to the right place. This tutorial will walk you through the process step by step, making it perfect for both beginners and experienced developers looking to brush up on their skills.

Before we dive in, make sure you have the latest version of .NET Core SDK installed on your machine. Also, you'll need a text editor or an Integrated Development Environment (IDE) like Visual Studio or Visual Studio Code.

Setting Up the ASP.NET Core Web API Project

For this tutorial, we'll be using the command line interface (CLI) to create our new project. This will allow you to follow along regardless of your preferred IDE.

To create a new Web API project, open your terminal or command prompt, navigate to the directory where you want to create your project, and then enter the following command:

Using the CLI to Create a New Project

In the terminal, type `dotnet new webapi -n MyWebApi` and press Enter. This will create a new Web API project named "MyWebApi" in the current directory.

The `-n` or `--name` parameter allows you to specify a name for your project. If you omit it, the project will be named "WebApplication1".

Running the Web API Locally

To run your new Web API project, navigate into the project directory and enter the following command:

`dotnet run`

This will start the ASP.NET Core runtime and launch your Web API. By default, it will be accessible at . You can verify this by opening a web browser and navigating to this address.

Creating Your First Controller

A controller in ASP.NET Core is a class that handles HTTP requests and generates HTTP responses. It defines which actions (methods) can respond to which HTTP requests.

Let's create a new controller called " zorganizvements". This controller will have an action to return a list of tasks and another action to get a specific task by its ID.

Creating the Tasks Controller

Right-click on the "Controllers" folder in your project and select "Add" > "Controller...">. Then, choose "RESTful API" and name it "TasksController". Click "Add" to create the controller.

A new file named "TasksController.cs" will be created in the "Controllers" folder. This file will contain the code for our new controller.

Defining the Controller Actions

In the "TasksController.cs" file, you'll see that it already contains a basic structure for a controller with a default "Get" action. We'll add another action to get a specific task by its ID.

To do this, add the following code to the "TasksController.cs" file:

```csharp [Route("api/[controller]")] [ApiController] public class TasksController : ControllerBase { // GET: api/tasks [HttpGet] public ActionResult> Get() { return new string[] { "Task 1", "Task 2", "Task 3" }; } // GET: api/tasks/5 [HttpGet("{id}")] public ActionResult Get(int id) { return "Task " + id; } } ```

We've defined two actions: one that returns a list of tasks when you navigate to the "api/tasks" URL, and another that returns a specific task when you navigate to a URL like "api/tasks/5".

Now that we've created our first controller, you can test your Web API by visiting or in your web browser. You should see the responses "Task 1", "Task 2", etc., depending on the URL you entered.

Consuming the Web API with a Client

So far, we've created a simple Web API that returns a list of tasks or a specific task by its ID. Now let's consume this Web API using a client, such as Postman or curl.

This will help you understand how to interact with your Web API from an external application.

Using Postman to Send HTTP Requests

Postman is a popular tool for testing and debugging Web APIs. Here's how to use it to send HTTP requests to our Web API:

1. Download and install Postman from if you haven't already.
2. Launch Postman and send a GET request to by inputting this URL in the address bar and pressing Enter. You should see the list of tasks we defined in our Web API.
3. To get a specific task, input (or any other ID) in the address bar and press Enter. You should see the response "Task 5".

Adding Models to Your Web API

So far, we've been returning simple strings from our Web API. But in a real-world application, you'll want to return data structures like models. Let's add models to our Web API and modify our controller to return these models instead of strings.

Creating the Task Model

Right-click on the "Models" folder in your project and select "Add" > "Class...">. Name it "Task" and click "Add". This will create a new file named "Task.cs". In this file, define the `Task` class as follows:

```csharp public class Task { public int Id { get; set; } public string Name { get; set; } public bool IsCompleted { get; set; } } ```

This `Task` class represents a task with properties for its ID, name, and completion status.

Modifying the Tasks Controller

Open the "TasksController.cs" file and update the `Get` and `Get(int id)` actions to return instances of the `Task` class instead of strings. Here's the updated code:

```csharp [HttpGet] public ActionResult> Get() { return new List { new Task { Id = 1, Name = "Task 1", IsCompleted = false }, new Task { Id = 2, Name = "Task 2", IsCompleted = true }, new Task { Id = 3, Name = "Task 3", IsCompleted = false } }; } [HttpGet("{id}")] public ActionResult Get(int id) { var tasks = new List { new Task { Id = 1, Name = "Task 1", IsCompleted = false }, new Task { Id = 2, Name = "Task 2", IsCompleted = true }, new Task { Id = 3, Name = "Task 3", IsCompleted = false } }; return tasks.Find(t => t.Id == id); } ```

Now, when you send a GET request to or using Postman or any other client, you'll receive a JSON response containing the corresponding `Task` object(s).

Congratulations! You've now successfully created and tested a Web API with ASP.NET Core. You've learned how to create a new project, create controllers and actions, consume the Web API using a client, and add models to your Web API. As you continue exploring ASP.NET Core Web APIs, remember to consult the official ASP.NET Core Web API documentation for more examples and advanced topics.

Looking for more challenges? Try adding support for creating, updating, and deleting tasks in your Web API, or explore how to validate and sanitize user input. Don't forget to share your creations and questions with the developer community on platforms like StackOverflow or Reddit. Happy coding!