在ASP.Net Core单例服务中使用Transient服务的可行性及风险咨询

你构思的这套方案存在根本性的生命周期问题，无法稳定运行，不要直接投入生产使用。

• 你注入到控制器的Transient/Scoped服务，生命周期是和当前请求绑定的。Action执行完毕、请求返回响应后，整个请求的服务Scope会被立刻销毁，你传入后台方法的_transientService2会被同步回收。如果后台任务还没执行完，在调用myTransientService2.GetSomethingNew时大概率会抛出ObjectDisposedException，只有后台任务碰巧在请求销毁前就执行完的极端场景能跑通，完全不可控。
• 无等待的后台任务如果抛出未处理异常，在ASP.NET Core 3.1中默认会触发进程终止，直接导致服务挂掉，风险极高。
• 没有限流、队列机制的话，短时间大量请求会生成大量失控的后台任务，会快速耗尽CPU、内存资源，直接把服务打垮。

用ASP.NET Core官方推荐的IHostedService+IServiceScopeFactory模式处理这类短生命周期后台任务，完全规避服务生命周期问题：

1. 实现一个线程安全的后台任务队列，作为单例服务注册
2. Action中仅把预缓存需要的参数传入队列，直接返回响应，不要传递任何服务实例
3. 专门的HostedService消费队列时，自己创建独立的服务Scope，从Scope中获取需要的Transient服务执行逻辑

示例代码如下：

第一步：实现后台任务队列 #

public interface IBackgroundTaskQueue
{
    void QueueBackgroundWorkItem(Func<IServiceProvider, CancellationToken, Task> workItem);
    Task<Func<IServiceProvider, CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken);
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly ConcurrentQueue<Func<IServiceProvider, CancellationToken, Task>> _workItems = new();
    private readonly SemaphoreSlim _signal = new(0);

    public void QueueBackgroundWorkItem(Func<IServiceProvider, CancellationToken, Task> workItem)
    {
        if (workItem == null) throw new ArgumentNullException(nameof(workItem));
        _workItems.Enqueue(workItem);
        _signal.Release();
    }

    public async Task<Func<IServiceProvider, CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken)
    {
        await _signal.WaitAsync(cancellationToken);
        _workItems.TryDequeue(out var workItem);
        return workItem;
    }
}

第二步：实现任务消费的HostedService #

public class QueuedHostedService : BackgroundService
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly IServiceProvider _serviceProvider;
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, IServiceProvider serviceProvider, ILogger<QueuedHostedService> logger)
    {
        _taskQueue = taskQueue;
        _serviceProvider = serviceProvider;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = await _taskQueue.DequeueAsync(stoppingToken);
            try
            {
                // 创建独立的服务Scope，生命周期和请求完全无关
                using var scope = _serviceProvider.CreateScope();
                await workItem(scope.ServiceProvider, stoppingToken);
            }
            catch (Exception ex)
            {
                // 必须捕获所有异常，避免进程崩溃
                _logger.LogError(ex, "预缓存后台任务执行失败");
            }
        }
    }
}

第三步：Startup中注册服务 #

public void ConfigureServices(IServiceCollection services)
{
    // 其他服务注册逻辑
    services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();
    services.AddHostedService<QueuedHostedService>();
}

第四步：控制器中调用 #

public class YourController : ControllerBase
{
    private readonly ITransientService1 _transientService1;
    private readonly IBackgroundTaskQueue _taskQueue;

    public YourController(ITransientService1 transientService1, IBackgroundTaskQueue taskQueue)
    {
        _transientService1 = transientService1;
        _taskQueue = taskQueue;
    }

    public async Task<IActionResult> GetSomething(string input1)
    {
        var resp = await _transientService1.GetSomethingElse(input1);
        // 仅传递需要的参数，不要传递任何服务实例
        var cacheParam = resp.someattr;
        _taskQueue.QueueBackgroundWorkItem(async (sp, ct) =>
        {
            // 从独立Scope中获取需要的服务
            var transientService2 = sp.GetRequiredService<ITransientService2>();
            var singletonService2 = sp.GetRequiredService<ISingletonService2>();
            var temp1 = await transientService2.GetSomethingNew(cacheParam, ct);
            await singletonService2.WriteCache(temp1, ct);
        });
        return Ok(resp);
    }
}

• 如果预缓存逻辑的可靠性要求较高，建议把队列换成持久化实现（比如基于Redis、MQ），避免服务重启时内存队列中未执行的任务丢失。
• 可以给队列增加长度限制，避免请求量突增时队列占用过多内存。
• 建议给后台任务增加去重逻辑，相同参数的预缓存任务重复提交时只执行一次，避免资源浪费。
• 可以给后台任务增加超时控制，避免单个任务卡死占住消费线程。

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