.NET 6中如何为WebApplication与HostedService配置不同依赖类及作用域

方法1：用键控/命名服务区分实现 #

如果是同一个接口需要不同实现，用键控服务（.NET 6+支持）或者命名实例来区分，注册时标记专属标识，注入时指定标识获取。

注册依赖 #

var builder = WebApplication.CreateBuilder(args);

// Web应用用的依赖，标记为"web"
builder.Services.AddKeyedScoped<IMyDependency, WebMyDependency>("web");
// 后台服务用的依赖，标记为"worker"
builder.Services.AddKeyedScoped<IMyDependency, WorkerMyDependency>("worker");

builder.Services.AddHostedService<AppServiceWorker>();
var app = builder.Build();

// Web端比如Controller里这么取：
// public HomeController([FromKeyedServices("web")] IMyDependency webDep)
// { ... }

app.Run();

后台服务里获取专属依赖 #

因为托管服务是单例，不能直接注入Scoped服务，得先创建作用域再拿：

public class AppServiceWorker : BackgroundService
{
    private readonly IServiceProvider _serviceProvider;

    public AppServiceWorker(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using var scope = _serviceProvider.CreateScope();
            // 获取标记为"worker"的依赖实例
            var workerDep = scope.ServiceProvider.GetRequiredKeyedService<IMyDependency>("worker");
            
            await workerDep.DoWork();
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}

方法2：给后台服务搞独立的服务容器（适合完全隔离场景） #

如果两类组件的依赖完全不想掺和，就单独给后台服务建个服务集合，构建成独立的服务提供者，再传给后台服务。

var builder = WebApplication.CreateBuilder(args);

// 先注册Web应用自己的依赖
builder.Services.AddScoped<IMyDependency, WebMyDependency>();

// 新建后台专属的服务集合
var workerServiceCollection = new ServiceCollection();
// 注册后台需要的所有依赖
workerServiceCollection.AddScoped<IMyDependency, WorkerMyDependency>();
workerServiceCollection.AddSingleton<WorkerOnlyService>();

// 构建后台的服务提供者
var workerServiceProvider = workerServiceCollection.BuildServiceProvider();

// 把这个独立容器传给后台服务
builder.Services.AddHostedService(_ => new AppServiceWorker(workerServiceProvider));

var app = builder.Build();
app.Run();

后台服务用独立容器的写法 #

public class AppServiceWorker : BackgroundService
{
    private readonly IServiceProvider _workerServiceProvider;

    public AppServiceWorker(IServiceProvider workerServiceProvider)
    {
        _workerServiceProvider = workerServiceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            using var scope = _workerServiceProvider.CreateScope();
            var workerDep = scope.ServiceProvider.GetRequiredService<IMyDependency>();
            
            await workerDep.DoWork();
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}

方法3：通过生命周期区分 #

如果只是依赖的作用域不同（比如Web用Scoped，后台用Singleton），直接注册时指定不同生命周期就行：

var builder = WebApplication.CreateBuilder(args);

// Web应用用Scoped
builder.Services.AddScoped<IMyDependency, WebScopedDep>();
// 后台服务用Singleton
builder.Services.AddSingleton<IMyDependency, WorkerSingletonDep>();

builder.Services.AddHostedService<AppServiceWorker>();
var app = builder.Build();
app.Run();

注意点 #

• 托管服务默认是单例，不能直接注入Scoped服务，必须通过IServiceProvider创建作用域后获取。
• 优先用键控/命名服务，独立容器复杂度高，除非真的需要完全隔离。

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