ASP.NET Core Middleware Configuration

In the previous article, we provided a detailed explanation of routing in ASP.NET Core—how incoming HTTP requests are dispatched to appropriate handlers based on their URLs. Next, we’ll delve into how to configure middleware in ASP.NET Core—a critical component for implementing application functionality.

What Is Middleware?

In ASP.NET Core, middleware refers to components that handle HTTP requests and responses. Middleware can perform various operations—such as request validation, logging, exception handling, or request transformation—and decide whether to pass the request onward to the next middleware in the pipeline.

Middleware operates as a processing pipeline: each middleware component can act both before the request enters the next stage and after the response returns from it. You can think of this as a chain of responsibility—each link has an opportunity to inspect or modify the request or response.

Configuring Middleware

Middleware is typically configured within the Configure method of the Startup.cs file. There, you add middleware components to the request-processing pipeline in the desired order. Here’s a simple example:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage(); // Shows detailed exception info in development
    }
    else
    {
        app.UseExceptionHandler("/Home/Error"); // Handles exceptions in production
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers(); // Routes requests to controllers
    });
}

In this example, several built-in middleware components are configured:

1. UseDeveloperExceptionPage: Displays detailed exception information during development.
2. UseExceptionHandler: Catches and handles unhandled exceptions in production.
3. UseHttpsRedirection: Redirects HTTP requests automatically to HTTPS.
4. UseStaticFiles: Serves static files (e.g., CSS, JavaScript, images).
5. UseRouting: Enables routing capabilities.
6. UseAuthorization: Enforces authorization policies.
7. UseEndpoints: Maps incoming requests to endpoints (e.g., controllers, Razor Pages).

Adding Custom Middleware

Beyond built-in middleware, you can create your own custom middleware—especially when you need specialized logic to process requests. Below is a simple example that logs the request path to the console on every request:

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine($"Request Path: {context.Request.Path}");
        
        // Pass the request to the next middleware in the pipeline
        await _next(context);
    }
}

To use this custom middleware in Startup.cs, register it in the Configure method like so:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<RequestLoggingMiddleware>(); // Register custom middleware

    // Other middleware configurations...
}

With this setup, every incoming request triggers RequestLoggingMiddleware, and its path is logged to the console.

Composing Middleware

Middleware components can be flexibly composed to build powerful, layered request-handling logic. You may define multiple custom middleware classes and insert them into the pipeline in Configure using app.UseMiddleware<T>(), specifying their execution order explicitly. Keep in mind that ordering matters significantly: requests flow forward through the pipeline in the order registered, while responses flow backward, returning through the same components in reverse order.

Conclusion

In this article, we explored how to configure middleware in ASP.NET Core. By understanding how middleware components are structured and how to arrange them sequentially, you gain fine-grained control over the flow of requests and responses.

In the next article, we’ll dive deeper into using built-in middleware, covering common scenarios and practical use cases for key built-in middleware components.

We hope this helps you better understand the relationship between routing and middleware in ASP.NET Core—and empowers you to build robust, maintainable applications.