ASP.NET Core  

What is Middleware in ASP.NET Core

Middleware is a fundamental concept in ASP.NET Core that defines how HTTP requests and responses are processed in the application pipeline. Every request passes through a sequence of middleware components before reaching the final endpoint, and each component can inspect, modify, or short-circuit the request.

Understanding middleware is essential for building scalable, secure, and maintainable web applications.

How Middleware Works

ASP.NET Core uses a request pipeline where each middleware component:

  • Receives an HTTP request

  • Performs some logic

  • Calls the next middleware in the pipeline

  • Optionally modifies the response

This pipeline is configured in Program.cs.

Middleware Pipeline Flow

Request → Middleware 1 → Middleware 2 → Middleware 3 → Endpoint
Response ← Middleware 1 ← Middleware 2 ← Middleware 3 ← Endpoint

Each middleware has control before and after the next middleware executes.

Basic Middleware Example

app.Use(async (context, next) =>
{
    Console.WriteLine("Request Incoming");

    await next();

    Console.WriteLine("Response Outgoing");
});

Explanation:

  • Code before next() runs during request processing

  • Code after next() runs during response processing

Types of Middleware

1. Built-in Middleware

ASP.NET Core provides several built-in middleware components:

  • Authentication Middleware

  • Authorization Middleware

  • Static Files Middleware

  • Routing Middleware

  • Exception Handling Middleware

Example:

app.UseAuthentication();
app.UseAuthorization();

2. Custom Middleware

You can create your own middleware to handle specific requirements.

Example: Custom Logging Middleware

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine($"Request: {context.Request.Method} {context.Request.Path}");

        await _next(context);

        Console.WriteLine($"Response Status: {context.Response.StatusCode}");
    }
}

Register Custom Middleware

app.UseMiddleware<LoggingMiddleware>();

Middleware Execution Order

Order matters in middleware configuration.

Example:

app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

Incorrect ordering can lead to issues such as:

  • Authentication not working

  • Endpoints not being reached

  • Middleware being skipped

Short-Circuiting Middleware

Middleware can stop further processing by not calling next().

app.Use(async (context, next) =>
{
    if (!context.Request.Headers.ContainsKey("Auth"))
    {
        context.Response.StatusCode = 401;
        await context.Response.WriteAsync("Unauthorized");
        return;
    }

    await next();
});

Real-World Use Cases

Middleware is commonly used for:

  • Logging requests and responses

  • Authentication and authorization

  • Exception handling

  • Request validation

  • Performance monitoring

Best Practices

  • Keep middleware lightweight and focused

  • Maintain correct order in pipeline

  • Avoid heavy processing inside middleware

  • Use built-in middleware when possible

Common Mistakes to Avoid

  • Incorrect middleware ordering

  • Forgetting to call next()

  • Adding unnecessary middleware

  • Handling business logic inside middleware

Conclusion

Middleware is the backbone of the ASP.NET Core request pipeline. It provides a powerful way to intercept, process, and manage HTTP requests and responses. By understanding middleware, developers can build flexible and efficient applications with better control over request processing.

Membership not found