Middleware and Custom Middleware

60 min

Middleware is software that's assembled into an application pipeline to handle requests and responses, processing HTTP requests as they flow through the pipeline. Middleware components are executed in the order they're registered. Each middleware can inspect, modify, or short-circuit requests. Understanding middleware enables you to add cross-cutting concerns (logging, authentication, error handling) to your application. Middleware is fundamental to ASP.NET Core's request processing.

Each middleware component chooses whether to pass the request to the next component in the pipeline by calling the next delegate or short-circuiting by not calling it. Calling `await _next(context)` passes the request to the next middleware. Not calling it short-circuits the pipeline. Middleware can execute code before and after the next middleware. Understanding middleware flow enables effective pipeline design. Middleware order matters—components execute in registration order.

You can create custom middleware for logging, authentication, error handling, and more, enabling application-specific request processing. Custom middleware is a class with an `InvokeAsync` method that receives HttpContext and a RequestDelegate. Middleware is registered in the pipeline using `app.UseMiddleware<T>()` or extension methods. Understanding custom middleware enables flexible request processing. Custom middleware is powerful for application-specific needs.

Built-in middleware includes authentication, authorization, CORS, routing, static files, and error handling. These middleware components handle common scenarios. Understanding built-in middleware enables effective application configuration. Built-in middleware is well-tested and production-ready.

Middleware can be conditionally executed based on request paths using `Map`, `MapWhen`, or `UseWhen`. Path-based routing enables different middleware for different routes. Understanding conditional middleware enables efficient request processing. Conditional middleware improves performance by avoiding unnecessary processing.

Best practices include ordering middleware correctly (authentication before authorization, error handling early), keeping middleware focused (single responsibility), using built-in middleware when possible, and understanding middleware lifetime. Understanding middleware enables effective request processing. Middleware is powerful but requires understanding execution order.

Key Concepts

Middleware handles requests and responses in a pipeline.
Middleware components execute in registration order.
Middleware can pass requests to next component or short-circuit.
Custom middleware enables application-specific request processing.
Middleware order matters for correct functionality.

Learning Objectives

Master

Understanding middleware pipeline and execution flow
Creating custom middleware components
Ordering middleware correctly
Using built-in middleware effectively

Develop

Understanding request processing architecture
Designing effective middleware pipelines
Appreciating middleware's role in ASP.NET Core

Tips

Order middleware correctly—authentication before authorization, error handling early.
Keep middleware focused on single responsibilities.
Use built-in middleware when possible—it's well-tested.
Understand that middleware executes in registration order.

Common Pitfalls

Ordering middleware incorrectly, causing unexpected behavior.
Not calling _next(context), short-circuiting the pipeline unintentionally.
Creating middleware that's too complex, violating single responsibility.
Not understanding middleware lifetime, causing issues.

Summary

Middleware handles requests and responses in a pipeline.
Middleware components execute in registration order.
Custom middleware enables application-specific processing.
Understanding middleware enables effective request processing.
Middleware is fundamental to ASP.NET Core.

Exercise

Create custom middleware for request logging.

// RequestLoggingMiddleware.cs
public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;
    
    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation($"Request: {context.Request.Method} {context.Request.Path}");
        
        await _next(context);
        
        _logger.LogInformation($"Response: {context.Response.StatusCode}");
    }
}

// Program.cs
app.UseMiddleware<RequestLoggingMiddleware>();

Middleware and Custom Middleware