Creating middleware in ASP.NET Core

Creating middleware in ASP.NET Core involves building a class that processes HTTP requests and responses. Middleware components are part of the request pipeline and can either handle the request themselves or pass it along to the next middleware in the pipeline.

Here’s how to create custom middleware in ASP.NET Core:

Steps to Create Middleware:

1. Create the Middleware Class

The middleware class needs to:

Have a constructor that takes a RequestDelegate (the next piece of middleware).
Implement an Invoke or InvokeAsync method that processes the request and optionally calls the next middleware in the pipeline.

Here’s an example:

public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

    // Constructor with RequestDelegate to call the next middleware in the pipeline
    public MyCustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    // The InvokeAsync method processes the HTTP request
    public async Task InvokeAsync(HttpContext context)
    {
        // Custom logic before the next middleware is called
        Console.WriteLine("Custom Middleware: Before next middleware");

        // Call the next middleware in the pipeline
        await _next(context);

        // Custom logic after the next middleware is called
        Console.WriteLine("Custom Middleware: After next middleware");
    }
}

2. Register the Middleware in the Pipeline

To use your custom middleware, you need to register it in the request pipeline in the Startup.cs (or Program.cs in .NET 6 and beyond) by using app.UseMiddleware<T>().

In Startup.cs (for .NET Core 3.1 and below) or Program.cs (for .NET 6+):

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Register your custom middleware
    app.UseMiddleware<MyCustomMiddleware>();

    // Other middlewares, like routing, endpoints, etc.
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Alternatively, you can use the Run, Use, or Map methods directly in the Configure method to register inline middleware.

3. Using Inline Middleware (Optional)

You can also create middleware inline in the Configure method using the app.Use, app.Run, or app.Map methods.

app.Use: Calls the next middleware in the pipeline.
app.Run: Does not call the next middleware. It short-circuits the pipeline.

public void Configure(IApplicationBuilder app)
{
    app.Use(async (context, next) =>
    {
        Console.WriteLine("Inline Middleware: Before next middleware");

        // Pass to the next middleware
        await next.Invoke();

        Console.WriteLine("Inline Middleware: After next middleware");
    });

    app.Run(async context =>
    {
        await context.Response.WriteAsync("Hello from terminal middleware!");
    });
}

4. Accessing HttpContext

In the middleware's InvokeAsync method, you can interact with the HttpContext object, which represents the HTTP request and response:

public async Task InvokeAsync(HttpContext context)
{
    // Access request information
    var requestPath = context.Request.Path;

    // Add a custom header to the response
    context.Response.Headers.Add("X-Custom-Header", "Middleware Demo");

    // Call the next middleware
    await _next(context);
}

5. Middleware Order Matters

The order in which you add middleware in the Configure method matters because middleware is executed in the order it’s added. Each middleware can either:

Perform work before or after the next middleware is called.
Short-circuit the pipeline by not calling the next middleware.

For example, authentication middleware should typically be placed early in the pipeline so that it can authenticate requests before other middleware like authorization or routing.

Example of Full Custom Middleware

// 1. Create the Middleware
public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        // Before the next middleware
        Console.WriteLine("Processing request...");

        // Call the next middleware in the pipeline
        await _next(context);

        // After the next middleware
        Console.WriteLine("Processing response...");
    }
}

// 2. Extension Method to Add Middleware Easily
public static class MyCustomMiddlewareExtensions
{
    public static IApplicationBuilder UseMyCustomMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<MyCustomMiddleware>();
    }
}

// 3. Register the Middleware in the Pipeline
public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Register the custom middleware
        app.UseMyCustomMiddleware();

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Conclusion:

Custom Middleware in ASP.NET Core is easy to implement and integrate.
Use middleware to handle cross-cutting concerns like logging, authentication, caching, and more.
The order of middleware registration in the pipeline is important for how requests and responses flow through your application.

Blog