如何确保DI控制器被释放前所有异步任务执行完成

问题根因 #

默认注入的DbContext为Scoped生命周期，和当前控制器/请求的生命周期绑定，请求处理完成后Scoped容器会被销毁，所有该容器下的服务（包括你的DbContext）都会被自动释放。你直接在Task.Run中使用当前请求注入的DbContext，Task还没执行完容器就被销毁，自然无法完成数据库写入。

可行解决方案 #

方案1：手动创建独立Scope（最快实现） #

通过构造函数注入IServiceScopeFactory，在后台任务中手动创建独立的服务Scope，使用该Scope下的DbContext，生命周期完全不受原请求影响。
代码示例：

// 首先在控制器构造函数注入IServiceScopeFactory
private readonly IServiceScopeFactory _scopeFactory;
public YourController(IServiceScopeFactory scopeFactory)
{
    _scopeFactory = scopeFactory;
}

public async ValueTask<RESPONSE_RESULT<string>> SomeMethod(CallContext context = default)
{
    try
    { 
        // 执行业务逻辑
    }
    catch (Exception ex)
    {
        // 丢弃任务返回值，避免未等待警告，可按需加异常处理
        _ = Task.Run(async () => 
        {
            try
            {
                // 创建独立Scope，用完自动释放
                using var scope = _scopeFactory.CreateScope();
                var dbContext = scope.ServiceProvider.GetRequiredService<你的DbContext类>();
                // 写入日志逻辑
                dbContext.异常日志表.Add(new 异常日志实体 { 内容 = ex.ToString() });
                await dbContext.SaveChangesAsync();
            }
            catch
            {
                // 兜底逻辑：比如写入本地文件/控制台日志，避免日志完全丢失
            }
        });
    }
    return default;
} 

方案2：使用DbContext工厂（EF Core 5+支持） #

注册时改为注入IDbContextFactory，在后台任务中直接创建新的DbContext实例，无需管理Scope。

1. 注册配置：

// Program.cs中注册DbContext工厂
builder.Services.AddDbContextFactory<你的DbContext类>(options =>
    options.UseSqlServer("你的数据库连接字符串"));

2. 控制器中使用：

// 构造函数注入IDbContextFactory
private readonly IDbContextFactory<你的DbContext类> _dbFactory;
public YourController(IDbContextFactory<你的DbContext类> dbFactory)
{
    _dbFactory = dbFactory;
}

// catch中逻辑
catch (Exception ex)
{
    _ = Task.Run(async () => 
    {
        using var dbContext = await _dbFactory.CreateDbContextAsync();
        dbContext.异常日志表.Add(new 异常日志实体 { 内容 = ex.ToString() });
        await dbContext.SaveChangesAsync();
    });
}

方案3：后台任务队列（生产环境推荐） #

如果日志写入量较大，建议使用内置的IHostedService实现异步日志队列，请求端仅需把日志丢入队列即可返回，由独立的后台服务统一消费写入数据库，完全避免抢占请求线程资源，稳定性更高。
简单实现示例：

1. 定义日志队列服务：

public interface ILogQueue
{
    void Enqueue(异常日志实体 log);
    Task<异常日志实体> DequeueAsync(CancellationToken ct);
}

public class LogQueue : ILogQueue
{
    private readonly ConcurrentQueue<异常日志实体> _queue = new();
    private readonly SemaphoreSlim _signal = new(0);

    public void Enqueue(异常日志实体 log)
    {
        _queue.Enqueue(log);
        _signal.Release();
    }

    public async Task<异常日志实体> DequeueAsync(CancellationToken ct)
    {
        await _signal.WaitAsync(ct);
        _queue.TryDequeue(out var log);
        return log;
    }
}

2. 实现后台消费服务：

public class LogBackgroundService : BackgroundService
{
    private readonly ILogQueue _queue;
    private readonly IServiceScopeFactory _scopeFactory;

    public LogBackgroundService(ILogQueue queue, IServiceScopeFactory scopeFactory)
    {
        _queue = queue;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var log = await _queue.DequeueAsync(stoppingToken);
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<你的DbContext类>();
            dbContext.Add(log);
            await dbContext.SaveChangesAsync(stoppingToken);
        }
    }
}

3. 注册服务：

builder.Services.AddSingleton<ILogQueue, LogQueue>();
builder.Services.AddHostedService<LogBackgroundService>();

4. 控制器中使用：

// 构造注入ILogQueue
private readonly ILogQueue _logQueue;
public YourController(ILogQueue logQueue)
{
    _logQueue = logQueue;
}

// catch中直接入队即可
catch (Exception ex)
{
    _logQueue.Enqueue(new 异常日志实体 { 内容 = ex.ToString() });
}

额外建议 #

如果仅需实现异常日志入库，无需自己造轮子，直接用成熟的日志框架（Serilog、NLog等），这些框架本身就支持异步批量写入数据库，配置后直接调用日志写入方法即可，稳定性和性能都优于自己实现的方案。

内容的提问来源于stack exchange，提问作者Asım Gündüz