Master .NET Core Web API Tutorial: Build RESTful Services Fast

Welcome to our comprehensive tutorial on creating a Web API using ASP.NET Core! If you're a developer looking to build powerful APIs for communication between web apps, services, and websites, this guide will walk you through the process step by step.

ASP.NET Core, an open-source framework by Microsoft, is renowned for its flexibility, efficiency, and cross-platform compatibility. By the end of this tutorial, you'll have a solid understanding of how to create, configure, and manage a Web API project using ASP.NET Core.

Setting Up Your ASP.NET Core Environment

Before diving into Web API creation, ensure you have the necessary tools installed. You'll need the .NET SDK (6.0 or later), which includes the dotnet command-line interface and Visual Studio or Visual Studio Code for development.

Verify your installation by opening a command prompt and typing:

dotnet --info

Creating a New ASP.NET Core Web API Project

Open your terminal or command prompt, then create a new Web API project with the following command:

dotnet new webapi -n MyWebApi

Replace "MyWebApi" with the desired name for your project. This command creates a new solution named "MyWebApi" with an "MyWebApi.csproj" file and an "MyWebApi" project within.

Running the New Web API Project

Navigate to the newly created project directory (e.g., cd MyWebApi) and run the following command to start the project:

dotnet run

Your new Web API should now be running. Open a web browser and navigate to https://localhost:5001 to view the default API response.

Adding and Configuring Controllers

Controllers in ASP.NET Core handle HTTP requests and generate HTTP responses. Let's add a new controller and configure it to return data.

Right-click on the "Controllers" folder in Solution Explorer, then select "Add" > "Controller" > "Controller with views, using Entity Framework" (or without views, depending on your needs). Name it "ProductsController".

Defining a Model Class

Right-click on the project (not the solution), select "Add" > "Class". Name it "Product.cs". Define a simple model class as follows:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Implementing the Controller

In the "ProductsController.cs" file, add a new action method to return a list of products:

public IEnumerable<Product> Get()
{
    var products = new List<Product>
    {
        new Product { Id = 1, Name = "Product A", Price = 9.99m },
        new Product { Id = 2, Name = "Product B", Price = 19.99m }
    };

    return products;
}

The generated product list will be returned as JSON in response to a GET request to the "/api/products" endpoint. To test this, stop the current application, then run:

dotnet run

Then, open your browser or Postman to send a GET request to https://localhost:5001/api/products.

Using Middleware in ASP.NET Core

Middleware in ASP.NET Core is responsible for handling HTTP requests and responses. Let's add a custom middleware to log request details.

Create a new class named "RequestResponseLoggingMiddleware.cs" with the following content:

public class RequestResponseLoggingMiddleware
{
    private readonly RequestDelegate _next;

    public RequestResponseLoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        writeRequestLoggingInformation(context);
        var originalBodyStream = context.Response.Body;

        // Create a new memory stream...
        var responseBodyMemoryStream = new MemoryStream();

        // Replace original response body with new memory stream
        context.Response.Body = responseBodyMemoryStream;

        await _next(context);

        // Return response body to original state
        responseBodyMemoryStream.Position = 0;
        await originalBodyStream.WriteAsync(responseBodyMemoryStream.ToArray());

        // Reset original body stream position
        originalBodyStream.Position = 0;
    }

    // Implement logging functionality here...
}

Registering the Middleware in the Pipeline

Open "Startup.cs" and add the middleware to the pipeline in the "Configure" method:

app.UseMiddleware<RequestResponseLoggingMiddleware>();

Ensure the middleware is registered between "app.UseRouting()" and "app.UseEndpoints()".

Building a Web API with ASP.NET Core opens up a world of possibilities for effective communication between applications. With this tutorial as a starting point, you're ready to explore more features and experiment with different data types, endpoints, and authentication methods.

Happy coding, and until next time – keep building incredible Web APIs with ASP.NET Core!