ASP.NET Core 8 Web API -

Middleware

Middleware in ASP.NET Core is software that's assembled into an application pipeline to handle requests and responses. Each component:

Middleware components can be used to handle authentication, logging, error handling, response compression, and more. This tutorial provides a comprehensive guide to understanding and implementing middleware in ASP.NET Core 8 Web API.

1. Introduction to Middleware

Middleware components are executed in the order they are added to the application pipeline. This order is critical because each middleware component can short-circuit the request processing and decide not to call the next middleware in the pipeline.

2. Built-in Middleware

ASP.NET Core includes several built-in middleware components for common tasks like routing, static files, and authentication. Here's a brief overview of some commonly used middleware:

Example: Adding Built-in Middleware 

        
            
var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseRouting(); // Adds routing middleware
app.UseAuthentication(); // Adds authentication middleware
app.UseAuthorization(); // Adds authorization middleware

app.MapControllers(); // Adds the endpoint routing middleware

app.Run();

3. Custom Middleware

You can create custom middleware to handle specific tasks in your application. Custom middleware is created by defining a class with a constructor and an Invoke or InvokeAsync method.

Example: Custom Logging Middleware

Create the Middleware Class 
        
            
public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LoggingMiddleware> _logger;

    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Handling request: " + context.Request.Path);
        await _next(context);
        _logger.LogInformation("Finished handling request.");
    }
}
Extension Method to Add Middleware 
        
            
public static class LoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseLoggingMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<LoggingMiddleware>();
    }
}
Add Middleware to the Pipeline 
        
            
var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseLoggingMiddleware(); // Adds the custom logging middleware

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

app.MapControllers();

app.Run();

4. Middleware Order

The order in which middleware is added to the pipeline is critical because each middleware can decide whether to pass the request to the next component. The order typically looks like this:

Example: Typical Middleware Order 

        
            
var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseExceptionHandler("/Home/Error"); // Exception handling middleware
app.UseStaticFiles(); // Serves static files

app.UseRouting(); // Adds routing middleware
app.UseAuthentication(); // Adds authentication middleware
app.UseAuthorization(); // Adds authorization middleware

app.MapControllers(); // Adds the endpoint routing middleware

app.Run();

5. Middleware with Dependency Injection

Middleware can take advantage of ASP.NET Core's built-in dependency injection (DI). You can inject services into your middleware's constructor.

Example: Middleware with Dependency Injection 

        
            
public class ExampleMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IExampleService _exampleService;

    public ExampleMiddleware(RequestDelegate next, IExampleService exampleService)
    {
        _next = next;
        _exampleService = exampleService;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _exampleService.PerformOperation();
        await _next(context);
    }
}

public static class ExampleMiddlewareExtensions
{
    public static IApplicationBuilder UseExampleMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<ExampleMiddleware>();
    }
}

6. Conditional Middleware Execution

You can conditionally execute middleware based on the request. For example, you might only want to use certain middleware for specific paths or HTTP methods.

Example: Conditional Middleware 

        
            
app.Use(async (context, next) =>
{
    if (context.Request.Path.StartsWithSegments("/api"))
    {
        // Execute middleware only for API requests
        await next();
    }
    else
    {
        // Skip the next middleware
        context.Response.StatusCode = StatusCodes.Status404NotFound;
    }
});

7. Middleware in Production vs. Development

It's a common practice to use different middleware configurations for development and production environments.

Example: Environment-Specific Middleware 

        
            
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage(); // Detailed error page in development
}
else
{
    app.UseExceptionHandler("/Home/Error"); // General error page in production
    app.UseHsts(); // Enforces HTTPS
}

app.UseHttpsRedirection(); // Redirects HTTP requests to HTTPS
app.UseStaticFiles(); // Serves static files

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

app.MapControllers();

app.Run();

8. Summary

Middleware is a powerful feature of ASP.NET Core 8 Web API, allowing you to build a robust request processing pipeline. By understanding how to use built-in middleware, create custom middleware, manage middleware order, and conditionally execute middleware, you can create flexible and maintainable web applications. This comprehensive guide should help you master middleware in ASP.NET Core 8 and apply best practices to your projects.