How does middleware form and return a response?

The middleware pipeline in ASP.NET Core is a chain of request handlers. Each middleware can either handle the request and generate a response or pass it to the next middleware in the chain.

Execution flow:

1. Request reception: The HTTP request arrives at ASP.NET Core, and an HttpContext is created.
2. Passing through the pipeline: The request passes through the middleware pipeline. Each middleware can perform actions before and after calling the next middleware (next(context)).
3. Response formation:
   • If a middleware decides to handle the request completely, it can directly write data to context.Response, set the status code, and headers. In this case, it may not call next(context), thus interrupting the further execution of the pipeline.
   • If a middleware only performs preliminary processing (e.g., authentication) and calls next(context), then the next middleware or the final handler (e.g., controller) can generate the response.
   • The response is formed by filling the properties of context.Response: StatusCode, Headers, Body.
4. Backward pass through the pipeline: After the final handler or one of the middleware forms the response, the execution flow goes back through the pipeline. Middleware that performed actions before calling next(context) can perform actions after it returns (e.g., logging).
5. Sending the response: The formed context.Response is sent to the client.

Example:

// Example middleware that adds a header and calls the next middleware
public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        // Actions before calling the next middleware
        context.Response.Headers.Add("X-Powered-By", "MyMiddleware");

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

        // Actions after response is returned (e.g., logging)
        Console.WriteLine($"Response status code: {context.Response.StatusCode}");
    }
}

// Example middleware that interrupts the pipeline and returns a response
public class ShortCircuitMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path == "/short-circuit")
        {
            context.Response.StatusCode = 400;
            await context.Response.WriteAsync("This request is blocked.");
            // Do not call _next(context), interrupting the pipeline
        }
        else
        {
            await _next(context);
        }
    }
}

Thus, the response is formed and returned either by the final handler (e.g., controller method) or by one of the middleware that decides not to pass the request further down the pipeline. The result is written to the HttpContext.Response object, which is then sent to the client.