依赖注入与中间件管线

// 1. 定义接口与实现
public interface IOrderRepository
{
    Task<Order?> GetAsync(int id);
}

public class OrderRepository : IOrderRepository
{
    public Task<Order?> GetAsync(int id) => Task.FromResult<Order?>(null);
}

// 2. 注册
builder.Services.AddScoped<IOrderRepository, OrderRepository>();

// 3. 消费：构造函数注入
public class OrderService(IOrderRepository repo)
{
    public async Task<Order?> GetAsync(int id) => await repo.GetAsync(id);
}

// Transient：每次解析都全新
builder.Services.AddTransient<ICache, InMemoryCache>();

// Scoped：同一个请求作用域内共享
builder.Services.AddScoped<IOrderRepository, OrderRepository>();

// Singleton：进程级唯一，需线程安全
builder.Services.AddSingleton<IAppConfig, AppConfig>();

// 错误：Singleton 捕获 Scoped → 运行时报错
public class ReportService(OrderRepository repo) { }  // repo 是 Scoped

// 正确：用 IServiceScopeFactory 手动开作用域
public class ReportService(IServiceScopeFactory scopeFactory)
{
    public async Task RunAsync()
    {
        await using var scope = scopeFactory.CreateScope();
        var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
        // 在此作用域内使用 repo
    }
}

请求 → [1] UseHttpsRedirection → [2] UseRouting → [3] UseAuthentication
          ↓ 放行                      ↓ 放行
      [4] UseAuthorization → [5] 终端路由执行（控制器）
          ↑
响应 ← 反向逐层返回（后进先出）

var app = builder.Build();

app.UseHttpsRedirection();      // 1. 先执行的中间件
app.UseRouting();               // 2. 路由匹配
app.UseAuthentication();        // 3. 身份认证
app.UseAuthorization();         // 4. 授权
app.MapControllers();           // 5. 终端执行

app.Run();

// 约定式中间件：记录请求耗时
public class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestTimingMiddleware> _logger;

    public RequestTimingMiddleware(RequestDelegate next,
        ILogger<RequestTimingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        try
        {
            await _next(context);              // 放行
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation("{Path} 耗时 {Elapsed}ms",
                context.Request.Path, sw.ElapsedMilliseconds);
        }
    }
}

// 注册
app.UseMiddleware<RequestTimingMiddleware>();

// 内联写法
app.Use(async (context, next) =>
{
    context.Response.Headers["X-Request-Id"] = Guid.NewGuid().ToString();
    await next();
});

// 按路径前缀分支
app.Map("/healthz", healthApp =>
{
    healthApp.Run(async ctx =>
    {
        ctx.Response.StatusCode = 200;
        await ctx.Response.WriteAsync("ok");
    });
});

// 按条件分支：只有 GET 进入业务管线
app.MapWhen(ctx => ctx.Request.Method == HttpMethods.Get, getApp =>
{
    getApp.UseAuth();
    getApp.MapControllers();
});

// 短路：静态缓存命中直接返回，不再往下走
app.Use(async (context, next) =>
{
    if (IsCached(context))
    {
        context.Response.StatusCode = 304;   // 短路
        return;
    }
    await next();
});

// 测试：单元验证中间件逻辑
public async Task TimingMiddleware_Should_Record_Elapsed()
{
    var logger = new Mock<ILogger<RequestTimingMiddleware>>();
    var middleware = new RequestTimingMiddleware(
        next: ctx => Task.CompletedTask,
        logger: logger.Object);

    var context = new DefaultHttpContext();

    await middleware.InvokeAsync(context);

    logger.Verify(l => l.Log(
        It.IsAny<LogLevel>(), It.IsAny<EventId>(),
        It.IsAny<It.IsAnyType>(), null, It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
        Times.Once);
}

// 集成验证：用 WebApplicationFactory 测整条管线
var factory = new WebApplicationFactory<Program>();
var client = factory.CreateClient();
var resp = await client.GetAsync("/api/orders/1");