深入解析ASP.NET Core Middleware：管道执行机制与性能优化

// 表示处理HTTP请求的委托
public delegate Task RequestDelegate(HttpContext context);

// 中间件的标准委托形式：接收下一个中间件，返回当前中间件的处理委托
public delegate RequestDelegate MiddlewareDelegate(RequestDelegate next);

// 应用构建器接口
public interface IApplicationBuilder
{
    // 注册中间件
    IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware);
    
    // 构建最终的请求处理委托
    RequestDelegate Build();
}

public class ApplicationBuilder : IApplicationBuilder
{
    private readonly List<Func<RequestDelegate, RequestDelegate>> _middlewares = new();
    
    public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
    {
        _middlewares.Add(middleware);
        return this;
    }
    
    public RequestDelegate Build()
    {
        // 最终的终端处理（返回404）
        RequestDelegate app = context =>
        {
            context.Response.StatusCode = 404;
            return Task.CompletedTask;
        };
        
        // 反向遍历中间件列表，构建委托链
        foreach (var middleware in _middlewares.Reverse())
        {
            app = middleware(app);
        }
        
        return app;
    }
}

public static IApplicationBuilder UseStaticFiles(this IApplicationBuilder app)
{
    return app.Use(next => context =>
    {
        // 1. 请求处理阶段：尝试返回静态文件
        if (TryServeStaticFile(context, out var task))
        {
            return task; // 短路管道，不调用next
        }
        
        // 2. 调用下一个中间件
        var nextTask = next(context);
        
        // 3. 响应处理阶段（可选）
        return nextTask.ContinueWith(_ =>
        {
            // 响应发送后的清理工作
        });
    });
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

namespace MiddlewareDemo
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);
            var app = builder.Build();

            // 中间件1：日志记录
            app.Use(async (context, next) =>
            {
                app.Logger.LogInformation("Middleware 1: 开始处理请求");
                // 调用下一个中间件
                await next(context);
                app.Logger.LogInformation("Middleware 1: 响应处理完成");
            });

            // 中间件2：请求处理
            app.Use(async (context, next) =>
            {
                app.Logger.LogInformation("Middleware 2: 处理请求");
                await context.Response.WriteAsync("Hello from Middleware 2!");
                // 不调用next，短路管道
                app.Logger.LogInformation("Middleware 2: 终止管道");
            });

            // 中间件3：永远不会执行（因为中间件2短路了）
            app.Use(async (context, next) =>
            {
                app.Logger.LogInformation("Middleware 3: 这行不会被执行");
                await next(context);
            });

            app.Run();
        }
    }
}

info: MiddlewareDemo.Program[0]
      Middleware 1: 开始处理请求
info: MiddlewareDemo.Program[0]
      Middleware 2: 处理请求
info: MiddlewareDemo.Program[0]
      Middleware 2: 终止管道
info: MiddlewareDemo.Program[0]
      Middleware 1: 响应处理完成

var app = WebApplication.CreateBuilder(args).Build();

// 公共日志中间件
app.Use(async (context, next) =>
{
    var start = DateTime.UtcNow;
    await next(context);
    app.Logger.LogInformation(
        "请求 {Path} 耗时 {Duration}ms",
        context.Request.Path,
        (DateTime.UtcNow - start).TotalMilliseconds);
});

// 分支1：API请求处理
app.MapWhen(context => context.Request.Path.StartsWithSegments("/api"), apiApp =>
{
    apiApp.UseHttpsRedirection();
    apiApp.UseAuthorization();
    apiApp.MapControllers();
});

// 分支2：静态文件请求
app.MapWhen(context => 
    context.Request.Path.StartsWithSegments("/static") ||
    context.Request.Path.HasExtension(), staticApp =>
{
    staticApp.UseStaticFiles();
});

// 默认分支
app.Run(async context =>
{
    await context.Response.WriteAsync("Default handler");
});

app.Run();

var app = WebApplication.CreateBuilder(args).Build();

// 错误：授权中间件在认证之前
app.UseAuthorization(); 
app.UseAuthentication();

app.MapGet("/secure", () => "Secure content")
   .RequireAuthorization();

app.Run();

// 正确顺序
app.UseAuthentication();  // 先认证
app.UseAuthorization();   // 后授权

// 中间件A设置数据
context.Items["TraceId"] = Guid.NewGuid().ToString();

// 中间件B获取数据
var traceId = context.Items["TraceId"] as string;

[Test]
public async Task MyMiddleware_ShouldAddHeader()
{
    // Arrange
    var context = new DefaultHttpContext();
    var middleware = new MyMiddleware(next: (c) => Task.CompletedTask);
    
    // Act
    await middleware.InvokeAsync(context);
    
    // Assert
    Assert.IsTrue(context.Response.Headers.ContainsKey("X-MyHeader"));
}