Is explicit constructor in middleware required in ASP.NET Core?

Not every middleware class in ASP.NET Core requires a constructor with a RequestDelegate parameter. While it's a common pattern for middleware to have this constructor, it's not mandatory. Let’s break down the scenarios to clarify:

1. Standard Middleware Pattern (Using RequestDelegate Constructor)

In most cases, middleware classes have a constructor that accepts a RequestDelegate parameter to allow the middleware to invoke the next component in the pipeline. This pattern is useful for middleware that wants to perform some logic and then pass control to the next middleware.

Example:

public class SimpleMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        // Custom logic here
        await _next(context); // Calls the next middleware
    }
}

This pattern requires the RequestDelegate to enable flow control through the pipeline.

2. Middleware without a RequestDelegate Constructor (Standalone Middleware)

In some cases, middleware does not need to call the next middleware, and therefore it can omit the RequestDelegate parameter altogether. This is usually rare and is applicable to terminal middleware, which ends the pipeline and does not pass requests further.

Example:

public class TerminalMiddleware
{
    public async Task InvokeAsync(HttpContext context)
    {
        // Custom logic here
        await context.Response.WriteAsync("This is a terminal middleware.");
    }
}

Here, TerminalMiddleware directly handles the response without relying on a RequestDelegate. Since it doesn’t call _next, it’s effectively ending the request pipeline at this middleware.

3. Middleware Implementing IMiddleware Interface

ASP.NET Core also provides the IMiddleware interface, which allows dependency injection directly into the InvokeAsync method rather than through the constructor. This middleware approach does not need to manage RequestDelegate manually because IMiddleware-based middleware is managed by the framework.

Example:

public class DependencyInjectedMiddleware : IMiddleware
{
    private readonly ILogger<DependencyInjectedMiddleware> _logger;

    public DependencyInjectedMiddleware(ILogger<DependencyInjectedMiddleware> logger)
    {
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        _logger.LogInformation("Running middleware with IMiddleware.");
        await next(context);
    }
}

In this example, DependencyInjectedMiddleware implements IMiddleware, and RequestDelegate is passed directly to InvokeAsync, so the constructor does not need it.

Summary

Middleware classes do not have to use a constructor with RequestDelegate, especially in scenarios like terminal middleware or when implementing IMiddleware.

If the middleware needs to call the next middleware in the pipeline, the standard pattern with a RequestDelegate constructor is usually used.

For terminal middleware or IMiddleware implementations, a RequestDelegate constructor isn’t required.

So, while the RequestDelegate constructor is common, it's not strictly required for all middleware in ASP.NET Core.