How to build custom middleware in ASP.NET Core

The request pipeline consists of a chain of middleware components that process incoming requests sequentially, where each component can either handle the request or pass it to the next in line.

Configuring the ASP.NET Core Middleware

The middleware pipeline in ASP.NET Core is configured using the Configure method in the Startup.cs file, where you can set up the sequence of middleware components. The Configure method is automatically invoked by the ASP.NET runtime.

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IdentityDbContext dbContext)
{
    app.UseDeveloperExceptionPage();           
    app.UseStaticFiles();          
    app.UseMvcWithDefaultRoute();
}

In this example, the code demonstrates how to add MVC to the ASP.NET Core request pipeline.

Create a custom ASP.NET Core middleware component

In ASP.NET Core, you can build your own custom middleware by using an extension method in IApplicationBuilder.

Right-click on the project in the Solution Explorer and add a new .cs file called MyCustomMiddleware.

public class MyCustomMiddleware
{
    // This is our custom middleware
}

Your custom middleware should include a constructor that accepts a RequestDelegate parameter. This delegate processes an HttpContext and returns a Task.

public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

Your middleware will need an Invoke method, which is called when the middleware is executed.

For example, how to check for a missing authentication key in the request header:

public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext httpContext)
    {
        if (!httpContext.Request.Headers.Keys.Contains("Authentication-Key"))
        {
            httpContext.Response.StatusCode = 400;
            await httpContext.Response.WriteAsync("Authentication key is missing...");
            return;
        }
        else
        {
            // Add your authentication key validation logic here.
        }

        await _next.Invoke(httpContext);
    }
}

In this example, if the request doesn't contain a valid authentication key, it responds with a message indicating the key is missing. (You can compare the Authentication-Key against a list of valid keys.)

Next, create an extension method to simplify registering the middleware in the pipeline.

public static class MyCustomMiddlewareExtensions
{
    public static IApplicationBuilder UseMyCustomMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<MyCustomMiddleware>();
    }
}

Finally, register the custom middleware in the Configure method using the extension method you created:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.UseMyCustomMiddleware();
}

This approach allows you to easily integrate custom middleware into your ASP.NET Core application.