Create a Custom Middleware Component in ASP.NET Core

ASP.NET Core middleware is a powerful feature that allows developers to customize the request pipeline by adding custom logic to handle incoming requests and outgoing responses. Middleware components are executed in a specific order, and each component has the opportunity to handle the request or pass it on to the next component in the pipeline.

Example of how you can create a custom middleware component in ASP.NET Core.

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)
    {
        try
        {
            // Log the request details
            _logger.LogInformation($"Request: {context.Request.Method} {context.Request.Path}");

            // Call the next middleware in the pipeline
            await _next(context);
        }
        catch (Exception ex)
        {
            // Log the exception
            _logger.LogError(ex, "An error occurred while processing the request.");
            throw;
        }
        finally
        {
            // Log the response details
            _logger.LogInformation($"Response: {context.Response.StatusCode}");
        }
    }
}

In this example, we create a LoggingMiddleware class that logs the request and response details to the console. The InvokeAsync method is the entry point for the middleware component. It receives an HttpContext object, which represents the current HTTP request and response.

Inside the InvokeAsync method, we first log the request details using the ILogger instance. Then, we call the _next delegate, which invokes the next middleware component in the pipeline. After the next middleware component has been completed, we log the response details.

To register the custom middleware component in the application's request pipeline, you can use the UseMiddleware extension method in the Startup.Configure method.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Other middleware components...

    app.UseMiddleware<LoggingMiddleware>();

    // Other middleware components...
}

This will add the LoggingMiddleware component to the request pipeline, and it will be executed for every incoming request.

Middleware components can be used for various purposes, such as logging, authentication, caching, compression, and more. ASP.NET Core also provides several built-in middleware components that you can use out of the box, such as UseStaticFiles, UseRouting, UseEndpoints, and UseAuthentication.