在C#中以线程安全方式实现Fire-and-Forget调用的问题

针对你的场景，核心问题是要让控制器立即返回，同时后台安全执行耗时的Import操作，还要避免DbContext被释放的异常。以下是两种可行的方案，不需要大规模重构现有代码：

方案一：手动创建服务作用域（快速解决） #

你之前用Task.Run出错的原因是直接复用了请求作用域内的MyService和DbContext，请求结束后这些实例会被DI容器释放。解决办法是在后台线程中创建独立的服务作用域，从新作用域中获取MyService实例，这样它的依赖（比如DbContext）会属于这个新作用域，不会被请求上下文影响。

代码示例 #

在控制器中注入IServiceScopeFactory，然后在后台任务中创建作用域：

private readonly IServiceScopeFactory _scopeFactory;

public ImportController(IServiceScopeFactory scopeFactory)
{
    _scopeFactory = scopeFactory;
}

[HttpPost("import")]
public IActionResult Import([FromBody] ImportConfig config)
{
    // 启动后台任务，使用_ = 避免未await警告
    _ = Task.Run(async () =>
    {
        // 创建独立的服务作用域
        using var scope = _scopeFactory.CreateScope();
        // 从新作用域获取MyService实例
        var myService = scope.ServiceProvider.GetRequiredService<MyService>();
        
        try
        {
            await myService.Import(config);
        }
        catch (Exception ex)
        {
            // 这里可以添加日志记录，捕获后台任务中的异常
            // _logger.LogError(ex, "后台导入任务失败");
        }
    });

    return Accepted("导入任务已启动，将在后台执行");
}

这个方案的优势是改动极小，不需要修改MyService的实现，只需要调整控制器的调用逻辑。

方案二：使用官方后台任务队列（更健壮） #

如果你的系统需要处理大量后台任务，或者需要流量控制、任务监控，ASP.NET Core官方推荐使用IHostedService结合后台任务队列的方式，这是更规范的后台任务实现方式。

步骤1：定义任务队列接口和实现 #

// 后台任务队列接口
public interface IBackgroundTaskQueue
{
    void QueueBackgroundWorkItem(Func<CancellationToken, Task> workItem);
    Task<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken);
}

// 基于Channel的队列实现（.NET 5+支持）
public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _queue;

    public BackgroundTaskQueue(int capacity)
    {
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        _queue = Channel.CreateBounded<Func<CancellationToken, Task>>(options);
    }

    public void QueueBackgroundWorkItem(Func<CancellationToken, Task> workItem)
    {
        if (workItem == null)
            throw new ArgumentNullException(nameof(workItem));
        
        _queue.Writer.TryWrite(workItem);
    }

    public async Task<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken)
    {
        return await _queue.Reader.ReadAsync(cancellationToken);
    }
}

步骤2：实现后台服务 #

public class QueuedHostedService : BackgroundService
{
    private readonly ILogger<QueuedHostedService> _logger;
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly IServiceScopeFactory _scopeFactory;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, 
                               ILogger<QueuedHostedService> logger,
                               IServiceScopeFactory scopeFactory)
    {
        _taskQueue = taskQueue;
        _logger = logger;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("后台任务队列服务已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = await _taskQueue.DequeueAsync(stoppingToken);

            try
            {
                // 为每个任务创建独立作用域
                using var scope = _scopeFactory.CreateScope();
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "后台任务执行失败");
            }
        }

        _logger.LogInformation("后台任务队列服务已停止");
    }
}

步骤3：注册服务（Startup.cs/Program.cs） #

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    // 注册后台任务队列，设置最大容量
    services.AddSingleton<IBackgroundTaskQueue>(new BackgroundTaskQueue(100));
    // 注册后台服务
    services.AddHostedService<QueuedHostedService>();
    // 注册你的MyService和DbContext（保持原有配置即可）
    services.AddScoped<MyService>();
    services.AddDbContext<MyDbContext>(options => 
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}

步骤4：控制器中使用队列 #

private readonly IBackgroundTaskQueue _taskQueue;
private readonly IServiceScopeFactory _scopeFactory;

public ImportController(IBackgroundTaskQueue taskQueue, IServiceScopeFactory scopeFactory)
{
    _taskQueue = taskQueue;
    _scopeFactory = scopeFactory;
}

[HttpPost("import")]
public IActionResult Import([FromBody] ImportConfig config)
{
    _taskQueue.QueueBackgroundWorkItem(async token =>
    {
        using var scope = _scopeFactory.CreateScope();
        var myService = scope.ServiceProvider.GetRequiredService<MyService>();
        await myService.Import(config);
    });

    return Accepted("导入任务已加入后台队列");
}

为什么你之前的方法失败？ #

• 不await异步方法：ASP.NET Core会跟踪请求范围内启动的所有异步操作，即使你不await，请求上下文也会等待这些操作完成，所以控制器无法立即返回。
• await + ConfigureAwait(false)：ConfigureAwait(false)只是避免捕获当前同步上下文，但你仍然await了方法，控制器会等到方法执行完毕才返回，不符合Fire-and-Forget的需求。
• 直接Task.Run调用MyService：MyService（或其依赖的DbContext）是请求作用域的，请求结束后DI容器会释放这些实例，后台线程再访问就会抛出ObjectDisposedException。

内容的提问来源于stack exchange，提问作者Shaggydog