.NET Core依赖注入：按依赖类解析服务/配置的方案咨询

场景1：配置注入差异化需求 #

类X和Y均依赖Config类型的配置，构造函数定义如下：

public class X
{
    public X(IOptions<Config> config)
    {
    }
}

public class Y
{
    public Y(IOptions<Config> config)
    {
    }
}

需求为X和Y的实例分别注入不同的Config配置。已知方案是命名配置+自定义解析器，但会导致X、Y需知晓解析器细节，多层依赖时问题更突出。期望实现类似按依赖类绑定配置的方式：

Host.CreateDefaultBuilder(args).ConfigureServices((context, services) => {
    services.Configure<Config>(context.Configuration.GetSection("ConfigA")).For<X>();
    services.Configure<Config>(context.Configuration.GetSection("ConfigB")).For<Y>();
});

补充1：第三方类无法修改构造函数 #

若X、Y为第三方库类，无法修改构造函数，如何实现X注入ConfigA、Y注入ConfigB？

补充2：通用按依赖类分配服务场景 #

问题不限于配置，而是通用的按依赖类分配服务的场景。例如：

class Stage {
  public Stage(string name, ISpeaker speaker) {
    ...
  }
}

class Speaker: ISpeaker {
  public Speaker(string name) {
    ...
  }
}

需要在组合根中动态配置：bigStage绑定loudSpeaker，smallStage绑定quietSpeaker，无需修改业务代码。

核心疑问 #

是否存在.NET Core内置的此类特性？或是否有更优的实现方案？

.NET Core 内置特性说明 #

.NET Core原生DI容器没有直接提供这种按依赖方绑定服务/配置的内置特性。原生的命名选项（IOptionsSnapshot<TOptions>+命名配置）需要依赖方显式指定配置名称，不符合“无需修改业务代码”的要求。

实现方案 #

方案1：针对配置注入场景（适配第三方类） #

通过封装扩展方法，结合原生命名选项机制，实现为特定依赖方注入对应配置的效果：

public static class ServiceCollectionExtensions
{
    public static IServiceCollection ConfigureFor<TTarget, TOptions>(
        this IServiceCollection services,
        IConfiguration configSection)
        where TOptions : class, new()
    {
        // 为目标类型注册唯一命名的配置
        var configKey = typeof(TTarget).FullName;
        services.Configure<TOptions>(configKey, configSection);
        
        // 为TTarget的依赖链注入对应命名的IOptions实例
        services.AddTransient<IOptions<TOptions>>(sp =>
        {
            var factory = sp.GetRequiredService<IOptionsFactory<TOptions>>();
            return factory.Create(configKey);
        }, typeof(TTarget));
        
        return services;
    }
}

使用方式：

Host.CreateDefaultBuilder(args).ConfigureServices((context, services) => {
    services.ConfigureFor<X, Config>(context.Configuration.GetSection("ConfigA"));
    services.ConfigureFor<Y, Config>(context.Configuration.GetSection("ConfigB"));
    
    services.AddTransient<X>();
    services.AddTransient<Y>();
});

该方案无需修改X/Y的构造函数，通过目标类型的全名称作为配置键，为其单独绑定配置实例。

方案2：通用按依赖类分配服务场景 #

对于通用服务绑定需求，可通过键控服务+自定义工厂实现：

1. 先注册带键标识的服务实例：

services.AddKeyedTransient<ISpeaker, Speaker>("loud", sp => new Speaker("LoudSpeaker"));
services.AddKeyedTransient<ISpeaker, Speaker>("quiet", sp => new Speaker("QuietSpeaker"));

2. 注册目标服务时指定对应的依赖：

services.AddTransient(sp => new Stage("BigStage", sp.GetRequiredKeyedService<ISpeaker>("loud")));
services.AddTransient(sp => new Stage("SmallStage", sp.GetRequiredKeyedService<ISpeaker>("quiet")));

若需批量绑定，可封装扩展方法简化操作：

public static IServiceCollection AddTransientWithDependency<TService, TDependency>(
    this IServiceCollection services,
    Func<IServiceProvider, TDependency> dependencyFactory)
    where TService : class
{
    services.AddTransient<TService>(sp =>
    {
        var ctor = typeof(TService).GetConstructors().First();
        var parameters = ctor.GetParameters()
            .Select(p => 
                p.ParameterType == typeof(TDependency) 
                    ? dependencyFactory(sp) 
                    : sp.GetRequiredService(p.ParameterType))
            .ToArray();
        return (TService)ctor.Invoke(parameters);
    });
    return services;
}

使用方式：

services.AddTransientWithDependency<Stage, ISpeaker>(sp => 
    sp.GetRequiredKeyedService<ISpeaker>("loud"));
services.AddTransientWithDependency<Stage, ISpeaker>(sp => 
    sp.GetRequiredKeyedService<ISpeaker>("quiet"));

方案3：第三方DI容器（如Autofac） #

若项目允许引入第三方DI容器，Autofac的上下文依赖绑定可更简洁实现需求：

• 配置场景：

builder.RegisterType<X>()
       .WithParameter(
           new ResolvedParameter(
               (pi, ctx) => pi.ParameterType == typeof(IOptions<Config>),
               (pi, ctx) => ctx.Resolve<IOptionsFactory<Config>>().Create("ConfigA")));

• 通用服务场景：

builder.Register(c => new Speaker("LoudSpeaker")).Named<ISpeaker>("loud");
builder.Register(c => new Speaker("QuietSpeaker")).Named<ISpeaker>("quiet");

builder.RegisterType<Stage>()
       .Named<Stage>("big")
       .WithParameter(
           (pi, ctx) => pi.ParameterType == typeof(ISpeaker),
           (pi, ctx) => ctx.ResolveNamed<ISpeaker>("loud"));

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