A Beginner's Guide to Middleware in ASP.NET Core

Middleware is a key part of ASP.NET Core, helping to handle HTTP requests and responses. In this blog, we'll explain what middleware is, how to use it, and provide an easy-to-understand example.

What is Middleware?

In ASP.NET Core, middleware is a piece of software that sits in the request pipeline to manage HTTP requests and responses. Each middleware component can perform actions on the request before passing it on to the next component, and on the response before sending it back to the client.

Why Use Middleware?

Middleware helps with common tasks like:

• Logging

• Error Handling

• Security (Authentication and Authorization)

• Compression

• Caching

How to Use Middleware

Here's how to use middleware in an ASP.NET Core application:

1. Create Middleware Class: Define what you want your middleware to do.

2. Add Middleware to the Pipeline: Register your middleware in the Program.cs file.

Example: Logging Middleware

Let's create middleware that logs the request path, request body, and response data.

LoggingMiddleware.cs

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        // Log request path
        Console.WriteLine("Request Path: " + context.Request.Path);

        // Log request body
        context.Request.EnableBuffering();
        using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8, leaveOpen: true))
        {
            var requestBody = await reader.ReadToEndAsync();
            Console.WriteLine("Request Body: " + requestBody);
            context.Request.Body.Position = 0;
        }

        // Capture and log response body
        var originalResponseBodyStream = context.Response.Body;
        using (var responseBodyStream = new MemoryStream())
        {
            context.Response.Body = responseBodyStream;

            await _next(context);

            context.Response.Body.Seek(0, SeekOrigin.Begin);
            var responseBody = await new StreamReader(context.Response.Body).ReadToEndAsync();
            Console.WriteLine("Response Data: " + responseBody);
            context.Response.Body.Seek(0, SeekOrigin.Begin);

            await responseBodyStream.CopyToAsync(originalResponseBodyStream);
        }
    }
}

Program.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;
using System.IO;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container if needed
// builder.Services.Add...

var app = builder.Build();

// Use your custom middleware
app.UseMiddleware<LoggingMiddleware>();

// Configure other middlewares and endpoints
app.UseRouting();

app.UseEndpoints(endpoints =>
{
    endpoints.MapGet("/", async context =>
    {
        await context.Response.WriteAsync("Hello, World!");
    });
});

app.Run();

Explanation

In this example:

• Request Path: The middleware logs the request path.

• Request Body: The middleware reads and logs the request body.

• Response Data: The middleware captures the response body and logs it before sending it to the client.

Conclusion

Middleware in ASP.NET Core makes handling HTTP requests and responses easy and modular. By using middleware, you can keep your code clean and organized. The logging middleware example shows how to log important details about requests and responses, helping you understand and debug your application better.