使用来自单例实例的 IServiceProvider 创建范围

Question

假设我有自己的类QueueListener<TService, TPayload> 继承自BackgroundService。它打开 TCP 连接并监听传入的消息。在每条消息上，我想初始化 TService 类型的服务并将反序列化的 JSON 实例 TPayload 传递给它。 TService 将被注册为 Transient，因此这意味着作为有效负载的处理程序必须是轻量级和无状态的（在我当前的任务中）。为此，我将在我的QueueListener 的构造函数中注入IServiceProvider，并在它收到的每条消息上创建一个范围。这听起来像是一个计划还是我过度设计？我想避免TService 也是单例。

文档says:

从单例解析作用域服务是很危险的。可能导致服务在处理后续请求时状态不正确。

但我不完全确定这意味着什么。无法在BackgroundService 中注入作用域服务，因为它具有单例生命周期。他们是否警告我不要再像现在这样做事了？

UPD #1

我解释了为什么我要为每条消息创建范围。其背后的想法是防止侦听器被消息处理阻塞，并为其他开发人员提供创建自己的处理程序并对收到的消息做一些事情的可能性。例如，其他开发人员可以在处理时创建数据库连接，我希望在处理完成后关闭并释放它。

Answer 1

将TService 注册为作用域并为每条消息创建一个新作用域。然后从创建的范围解析TService。请阅读Consuming a scoped service in a background task

你可以这样写：

services.AddHostedService<MyBackgroundService>();
services.AddScoped<IScopedServicePerMessage, ScopedServicePerMessage>();

...

public class MyBackgroundService : BackgroundService
{
    private readonly IServiceProvider _sp;
    public MyBackgroundService(IServiceProvider sp)
    {
        _sp = sp;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        DoWork(stoppingToken);
        return Task.CompletedTask;
    }

    private void DoWork(CancellationToken stoppingToken)
    {
        while(true)
        {
            var msg = GetNextMessage();
            using (var scope = _sp.CreateScope())
            {
                var servicePerMessage = scope.ServiceProvider.GetRequiredService<IScopedServicePerMessage>();
                servicePerMessage.Handle(msg);
            }
        }
    }
    ...
}

关于这个：

从单例解析作用域服务是很危险的。它可能 导致服务在处理后续请求时状态不正确。

这是关于将作用域服务（例如，ef core dbcontext）直接注入单例的情况。这不是你的情况。

Answer 2

文档是指将范围内的服务注入到单例服务中。由于注入发生在单例对象的构造中，因此将在那时提供作用域服务。这将有效地将作用域服务的生命周期延长到单例服务的生命周期。这是很危险的，因为通常会明确选择范围服务生命周期以确保对象再次被快速释放。

最常见的例子是拥有数据库连接的数据库上下文；您要确保尽快释放此数据库连接以释放资源。但是如果你将上下文注入到单例服务中，它永远不会被释放。

但这并不意味着无法在单例服务中使用作用域服务。这是通过让单例服务创建一个服务范围来完成的，然后它可以从中检索单例服务。重要的是，这个服务范围应该是短暂的。因此，以 ASP.NET Core 本身为例，其中为每个请求创建一个服务范围，并执行类似的操作。例如，在您的情况下，如果这对您的应用程序有意义，您可以为每条传入消息执行此操作。

要创建一个服务范围，你应该注入一个IServiceScopeFactory；然后你可以像这样用它创建一个范围：

public async Task Process(TPayload payload)
{
    using (var scope = _serviceScopeFactory.CreateScope())
    {
        var service = scope.GetService<TService>();

        await service.Process(payload);
    }
}

仅当您需要使用作用域服务时，才严格需要此模式。您可以直接解析所有其他服务，而无需创建范围。如果您可以重用相同的服务实例来处理所有有效负载，您还可以将服务作为单例注入（与将其注册为瞬态但仅解析一次相同）。如果您需要为每个有效负载创建一个新实例，那么请考虑创建一个范围，即使它不是绝对必要的。

Answer 3

首先，transient services are not scoped services。瞬态服务通常由您的代码在外部拥有，并在每次从容器中解析时创建。容器不缓存瞬态服务。

TService 将被注册为 Transient ... 为此，我将在我的 QueueListener 的构造函数中注入 IServiceProvider 并在它收到的每条消息上创建一个范围。

您不需要解析瞬态服务的范围。即使您创建了一个范围，该范围仍然不管理/拥有瞬态服务。例如，结束作用域的生命周期并不会结束瞬态服务的生命周期。

您可以简单地使用QueueListener 中注入的IServiceProvider 来解析TService。并且每个TService 解决的都应该已经是你想要的了

作为有效载荷处理程序的轻量级和无状态

关于

文档说：

由于您没有使用范围服务，因此文档中的内容现在可能不相关。但如果你想知道原因：

从单例解析作用域服务很危险。

单例是一种特殊的作用域。单例服务在容器的“根”范围内创建和缓存，本质上是容器本身。

如果您从单例解析范围服务，则解析和缓存服务实例的生命周期/范围很可能是“根”范围。这导致了一个问题，即作用域服务实例被缓存在容器内，并在多个客户端请求之间共享。

这是危险的，因为范围服务应该是

每个客户端请求（连接）创建一次范围生命周期服务 (AddScoped)。

Answer 4

我不希望我的单例类直接依赖于 IServiceProvider。 所以我使用了一个定制工厂来实现这个目标。 愿此代码示例对其他人有所帮助：

public class Startup
{
    // ...

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IScopedBar, ScopedBar>();

        services.AddSingleton<IScopedServiceFactory<IScopedBar>, ScopedServiceFactory<IScopedBar>>(
            (provider) => {
                var scope = provider.CreateScope();
                var service = scope.ServiceProvider.GetRequiredService<IScopedBar>();
                
                return new ScopedServiceFactory<IScopedBar>(() => new ScopedService<IScopedBar>(scope, service));
            });

        services.AddSingleton<ISingletonFoo, SingletonFoo>();
    }

    // ...
}

public interface ISingletonFoo
{
    void DoSomethingUsingScopedServices();
}

public class SingletonFoo : ISingletonFoo
{
    private readonly IScopedServiceFactory<IScopedBar> _barFactory;

    public SingletonFoo(IScopedServiceFactory<IScopedBar> barFactory)
    {
        _barFactory = barFactory;
    }

    public void DoSomethingUsingScopedServices()
    {
        using var scopedService = _barFactory.CreateService();
        scopedService.Service.DoSomething();
    }
}

public interface IScopedBar
{
    void DoSomething();
}

public class ScopedBar : IScopedBar
{
    public void DoSomething()
    {
        // Do something
    }
}

public interface IScopedService<T> : IDisposable
{
    T Service { get; }
}

public interface IScopedServiceFactory<T>
{
    IScopedService<T> CreateService();
}

public class ScopedService<T> : IScopedService<T>
{
    private readonly IDisposable _scope;
    
    public ScopedService(IDisposable scope, T service)
    {
        _scope = scope;
        Service = service;
    }

    public T Service { get; }

    public void Dispose()
    {
        _scope.Dispose();
    }
}

public class ScopedServiceFactory<T> : IScopedServiceFactory<T>
{
    private readonly Func<IScopedService<T>> _serviceFactory;

    public ScopedServiceFactory(Func<IScopedService<T>> serviceFactory)
    {
        _serviceFactory = serviceFactory;
    }

    public IScopedService<T> CreateService()
    {
        return _serviceFactory();
    }
}