1
var builder = WebApplication.CreateBuilder(args);
2

3
// === 阶段 1：服务注册 (仅允许配置 IServiceCollection) ===
4
builder.Services.AddControllers();
5
builder.Services.AddEndpointsApiExplorer();
6
builder.Services.AddSwaggerGen();
7

8
// 配置日志与配置中心
9
builder.Logging.ClearProviders();
10
builder.Logging.AddConsole();
11

12
var app = builder.Build(); // [分水岭] 容器在此处构建并锁定
13

14
// === 阶段 2：管道配置 (仅允许编排 IApplicationBuilder / IEndpointRouteBuilder) ===
15
if (app.Environment.IsDevelopment())
16
{
17
    app.UseSwagger();
18
    app.UseSwaggerUI();
19
}
20

21
app.UseHttpsRedirection();
22
app.UseAuthentication();
23
app.UseAuthorization();
24
app.MapControllers();
25

26
app.Run();

1
public class RequestPerformanceMiddleware
2
{
3
    private readonly RequestDelegate _next;
4
    private readonly ILogger<RequestPerformanceMiddleware> _logger;
5

6
    // 构造函数：只能注入 Singleton 服务
7
    public RequestPerformanceMiddleware(RequestDelegate next, ILogger<RequestPerformanceMiddleware> logger)
8
    {
9
        _next = next;
10
        _logger = logger;
11
    }
12

13
    // 方法级参数注入：可以注入 Scoped 服务 (如 AppDbContext)
14
    public async Task InvokeAsync(HttpContext context, IMetricService metricService)
15
    {
16
        var sw = Stopwatch.StartNew();
17
        try
18
        {
19
            await _next(context); // 调用下一个中间件
20
        }
21
        finally
22
        {
23
            sw.Stop();
24
            metricService.RecordLatency(context.Request.Path, sw.ElapsedMilliseconds);
25
            _logger.LogInformation("Path: {Path} 耗时: {Elapsed}ms", context.Request.Path, sw.ElapsedMilliseconds);
26
        }
27
    }
28
}

1
public class TenantResolutionMiddleware : IMiddleware
2
{
3
    private readonly ITenantDbContext _tenantDb; // 可以直接在构造函数注入 Scoped 服务
4

5
    public TenantResolutionMiddleware(ITenantDbContext tenantDb)
6
    {
7
        _tenantDb = tenantDb;
8
    }
9

10
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
11
    {
12
        var tenantCode = context.Request.Headers["X-Tenant-Id"].FirstOrDefault();
13
        if (!string.IsNullOrEmpty(tenantCode))
14
        {
15
            await _tenantDb.SwitchTenantAsync(tenantCode);
16
        }
17
        await next(context);
18
    }
19
}

1
public class ApiAuditMiddleware
2
{
3
    private readonly RequestDelegate _next;
4
    private const string CorrelationHeaderName = "X-Correlation-ID";
5

6
    public ApiAuditMiddleware(RequestDelegate next)
7
    {
8
        _next = next;
9
    }
10

11
    public async Task InvokeAsync(HttpContext context, ILogger<ApiAuditMiddleware> logger)
12
    {
13
        // 1. 链路追踪 ID 注入与回传
14
        if (!context.Request.Headers.TryGetValue(CorrelationHeaderName, out var correlationId)
15
            || string.IsNullOrWhiteSpace(correlationId))
16
        {
17
            correlationId = Guid.NewGuid().ToString("N");
18
        }
19
        context.TraceIdentifier = correlationId!;
20
        context.Response.Headers.Append(CorrelationHeaderName, correlationId);
21

22
        // 2. 将 CorrelationId 绑定到当前异步日志上下文 (Serilog LogContext)
23
        using (logger.BeginScope(new Dictionary<string, object> { ["CorrelationId"] = correlationId }))
24
        {
25
            // 3. 启用请求缓冲机制：支持流指针倒回 (Seek)
26
            context.Request.EnableBuffering();
27

28
            // 4. 安全读取请求体进行审计记录
29
            string requestBodyText = await ReadRequestBodyAsync(context.Request);
30
            logger.LogInformation("HTTP {Method} {Path} Payload: {Body}",
31
                context.Request.Method, context.Request.Path, requestBodyText);
32

33
            // 5. 调用下游业务
34
            await _next(context);
35
        }
36
    }
37

38
    private static async Task<string> ReadRequestBodyAsync(HttpRequest request)
39
    {
40
        if (request.ContentLength is null or 0 || !request.Body.CanSeek)
41
        {
42
            return string.Empty;
43
        }
44

45
        // 读取前将指针重置到流起始位置
46
        request.Body.Position = 0;
47
        using var reader = new StreamReader(request.Body, Encoding.UTF8, leaveOpen: true);
48
        var body = await reader.ReadToEndAsync();
49

50
        // 关键点：读取完毕后必须重置回 0，留给后续 ModelBinding 消费！
51
        request.Body.Position = 0;
52
        return body;
53
    }
54
}

1
flowchart TD
2
    subgraph 错误陷阱：单例捕获
3
        S[Singleton: DeviceTelemetryManager] -->|构造注入持久引用| C["Scoped: AppDbContext (生命周期被绑架，永不释放！)"]
4
        Req1[Thread 1: HTTP Request A] --> S
5
        Req2[Thread 2: HTTP Request B] --> S
6
        S -->|并发冲突报错崩盘| C
7
    end

1
var builder = WebApplication.CreateBuilder(new WebApplicationOptions
2
{
3
    Args = args,
4
    // 强制开启作用域与单例捕获验证
5
    EnvironmentName = Environments.Development
6
});

1
public class EnterpriseBatchProcessingWorker : BackgroundService
2
{
3
    private readonly IServiceScopeFactory _scopeFactory;
4
    private readonly ILogger<EnterpriseBatchProcessingWorker> _logger;
5

6
    // 单例 Worker 仅注入 IServiceScopeFactory，严禁直接注入 DbContext 等 Scoped 服务
7
    public EnterpriseBatchProcessingWorker(
8
        IServiceScopeFactory scopeFactory,
9
        ILogger<EnterpriseBatchProcessingWorker> logger)
10
    {
11
        _scopeFactory = scopeFactory;
12
        _logger = logger;
13
    }
14

15
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
16
    {
17
        while (!stoppingToken.IsCancellationRequested)
18
        {
19
            try
20
            {
21
                // 1. 显式创建隔离的局部作用域 (Scope)
22
                using (var scope = _scopeFactory.CreateScope())
23
                {
24
                    // 2. 从当前局部作用域中安全解析 Scoped 服务 (如 AppDbContext、IOrderService)
25
                    var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
26
                    var orderService = scope.ServiceProvider.GetRequiredService<IOrderProcessingService>();
27

28
                    // 业务：扫描超时未支付订单并原子释放库存/锁座位
29
                    await orderService.CancelTimeoutPendingOrdersAsync(dbContext, stoppingToken);
30
                }
31
                // 3. 退出 using 块，scope 内部的所有 Scoped 实例及 DbContext 链接被立即优雅释放与回收
32
            }
33
            catch (Exception ex)
34
            {
35
                _logger.LogError(ex, "后台批处理作业执行异常");
36
            }
37

38
            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
39
        }
40
    }
41
}