如何在ASP.NET Core 2中用键或工厂解析依赖及实现标识化注入？

嘿，这个问题问得很到位！ASP.NET Core 2的原生依赖注入容器确实不像Unity那样直接支持基于键（key）的注册和注入，但咱们有好几种办法实现类似效果，我给你一步步讲清楚：

这是最符合ASP.NET Core DI设计理念的方式，通过一个工厂类来根据键返回对应的服务实现。

假设我们有一个接口IService和两个实现类：

public interface IService { void DoWork(); }
public class ServiceA : IService { public void DoWork() => Console.WriteLine("Service A 正在干活"); }
public class ServiceB : IService { public void DoWork() => Console.WriteLine("Service B 正在干活"); }

先写一个工厂类，注入IServiceProvider来获取注册的服务：

public class ServiceFactory
{
    private readonly IServiceProvider _serviceProvider;

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

    public IService GetService(string key)
    {
        return key switch
        {
            "A" => _serviceProvider.GetRequiredService<ServiceA>(),
            "B" => _serviceProvider.GetRequiredService<ServiceB>(),
            _ => throw new ArgumentException($"找不到对应键的服务：{key}")
        };
    }
}

接着在Startup.cs的ConfigureServices里注册所有服务和工厂：

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<ServiceA>();
    services.AddTransient<ServiceB>();
    services.AddTransient<ServiceFactory>();
    // 其他服务注册（比如Mvc）...
}

最后在需要使用的地方注入工厂，通过键获取对应服务：

public class HomeController : Controller
{
    private readonly IService _serviceA;
    private readonly IService _serviceB;

    public HomeController(ServiceFactory factory)
    {
        _serviceA = factory.GetService("A");
        _serviceB = factory.GetService("B");
    }

    public IActionResult Index()
    {
        _serviceA.DoWork();
        _serviceB.DoWork();
        return View();
    }
}

如果想更贴近Unity的[Dependency("key")]特性，我们可以结合“注入接口的所有实现”+自定义特性筛选的方式。

首先定义一个标记键的特性：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Parameter)]
public class ServiceKeyAttribute : Attribute
{
    public string Key { get; }
    public ServiceKeyAttribute(string key) => Key = key;
}

给每个实现类打上特性标记：

[ServiceKey("A")]
public class ServiceA : IService { /* ... */ }

[ServiceKey("B")]
public class ServiceB : IService { /* ... */ }

在Startup.cs里注册所有IService的实现：

services.AddTransient<IService, ServiceA>();
services.AddTransient<IService, ServiceB>();

然后写个扩展方法，用来从批量注入的服务中根据键筛选：

public static class ServiceExtensions
{
    public static IService GetByKey(this IEnumerable<IService> services, string key)
    {
        var targetService = services.FirstOrDefault(s => 
            s.GetType().GetCustomAttribute<ServiceKeyAttribute>()?.Key == key);
        
        return targetService ?? throw new ArgumentException($"没有找到键为{key}的服务");
    }
}

之后在控制器里就可以这样用：

public class HomeController : Controller
{
    private readonly IService _serviceA;

    public HomeController(IEnumerable<IService> allServices)
    {
        _serviceA = allServices.GetByKey("A");
    }
}

如果原生方式满足不了复杂场景，你可以把ASP.NET Core的原生容器换成支持键控注入的第三方容器，比如Autofac。

首先安装Autofac的ASP.NET Core包：

Install-Package Autofac.Extensions.DependencyInjection

然后修改Startup.cs的ConfigureServices方法，返回Autofac的服务提供者：

public IServiceProvider ConfigureServices(IServiceCollection services)
{
    // 先注册原生服务（比如Mvc）
    services.AddMvc();

    // 创建Autofac容器构建器
    var builder = new ContainerBuilder();

    // 用Named方式注册服务，指定键
    builder.RegisterType<ServiceA>().Named<IService>("A");
    builder.RegisterType<ServiceB>().Named<IService>("B");

    // 将原生服务集合导入Autofac
    builder.Populate(services);

    // 构建容器并返回服务提供者
    var container = builder.Build();
    return new AutofacServiceProvider(container);
}

接下来在控制器里，通过Autofac提供的IIndex<string, IService>索引器来获取指定键的服务：

public class HomeController : Controller
{
    private readonly IService _serviceA;

    public HomeController(IIndex<string, IService> serviceIndex)
    {
        _serviceA = serviceIndex["A"];
    }
}

Autofac还支持类似Unity的属性注入，你可以在属性上标记[Named("A")]来实现自动注入，非常灵活。

ASP.NET Core 2原生DI虽然没有内置键控注入，但通过工厂模式、自定义特性筛选，或者替换第三方容器，都能实现和Unity的[Dependency("key")]类似的效果。其中工厂模式是最轻量化、最贴合原生设计的方案，复杂场景下第三方容器会是更好的选择。

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