[C#] Asp.Net Core에서 동일한 인터페이스의 여러 구현을 등록하는 방법은 무엇입니까?

동일한 인터페이스에서 파생 된 서비스가 있습니다.

public interface IService { }
public class ServiceA : IService { }
public class ServiceB : IService { }
public class ServiceC : IService { }

일반적으로 다른 IoC 컨테이너를 Unity사용하면 구체적인 구현을 구체적으로 등록 할 수 Key있습니다.

ASP.NET Core에서 이러한 서비스를 등록하고 일부 키를 기반으로 런타임에 어떻게 해결합니까?

나는 구체적인 구현을 구별하기 위해 일반적으로 사용되는 또는 매개 변수 Add를 사용하는 서비스 메소드를 보지 못했습니다 .keyname

    public void ConfigureServices(IServiceCollection services)
    {
         // How do I register services of the same interface?            
    }


    public MyController:Controller
    {
       public void DoSomething(string key)
       {
          // How do I resolve the service by key?
       }
    }

여기에서 팩토리 패턴이 유일한 옵션입니까?

Update1 여기 에서는 여러 구체적인 구현이있을 때 팩토리 패턴을 사용하여 서비스 인스턴스를 얻는 방법을 보여주는
기사를 보았습니다 . 그러나 여전히 완벽한 솔루션은 아닙니다. 내가 전화하면_serviceProvider.GetService()메서드를 하면 생성자에 데이터를 주입 할 수 없습니다.

예를 들어 이것을 고려하십시오 :

public class ServiceA : IService
{
     private string _efConnectionString;
     ServiceA(string efconnectionString)
     {
       _efConnecttionString = efConnectionString;
     }
}

public class ServiceB : IService
{
   private string _mongoConnectionString;
   public ServiceB(string mongoConnectionString)
   {
      _mongoConnectionString = mongoConnectionString;
   }
}

public class ServiceC : IService
{
    private string _someOtherConnectionString
    public ServiceC(string someOtherConnectionString)
    {
      _someOtherConnectionString = someOtherConnectionString;
    }
}

_serviceProvider.GetService()적절한 연결 문자열을 어떻게 주입 할 수 있습니까? Unity 또는 다른 IoC 라이브러리에서는 형식 등록시이를 수행 할 수 있습니다. 그러나 IOption 을 사용할 수 있지만 모든 설정을 주입해야합니다. 서비스에 특정 연결 문자열을 삽입 할 수 없습니다.

또한 다른 컨테이너 (Unity 포함)를 사용하지 않으려 고합니다. 다른 컨테이너 (예 : 컨트롤러)를 새 컨테이너에 등록해야하기 때문입니다.

또한 팩토리 패턴을 사용하여 서비스 인스턴스를 작성하는 것은 클라이언트가 여기에 세부 사항을 갖는 종속성 수가 증가하므로 DIP에 대한 것입니다. 입니다.

따라서 ASP.NET Core의 기본 DI에는 두 가지가 빠져 있다고 생각합니다.

1. 키를 사용하여 인스턴스를 등록하는 기능
2. 등록하는 동안 정적 데이터를 생성자에 주입하는 기능

답변

public delegate IService ServiceResolver(string key);

services.AddTransient<ServiceA>();
services.AddTransient<ServiceB>();
services.AddTransient<ServiceC>();

services.AddTransient<ServiceResolver>(serviceProvider => key =>
{
    switch (key)
    {
        case "A":
            return serviceProvider.GetService<ServiceA>();
        case "B":
            return serviceProvider.GetService<ServiceB>();
        case "C":
            return serviceProvider.GetService<ServiceC>();
        default:
            throw new KeyNotFoundException(); // or maybe return null, up to you
    }
});

public class Consumer
{
    private readonly IService _aService;

    public Consumer(ServiceResolver serviceAccessor)
    {
        _aService = serviceAccessor("A");
    }

    public void UseServiceA()
    {
        _aService.DoTheThing();
    }
}

services.AddSingleton<IService, ServiceA>();
services.AddSingleton<IService, ServiceB>();
services.AddSingleton<IService, ServiceC>();

var services = serviceProvider.GetServices<IService>();
var serviceB = services.First(o => o.GetType() == typeof(ServiceB));

var serviceZ = services.First(o => o.Name.Equals("Z"));

    public interface IPet
    {
        string Name { get; set; }
    }

    public class Cat : IPet
    {
        public Cat(string name)
        {
            Name = name;
        }

        public string Name {get; set; }
    }

var mongoConnection = //...
var efConnection = //...
var otherConnection = //...
services.AddTransient<IMyFactory>(
             s => new MyFactoryImpl(
                 mongoConnection, efConnection, otherConnection,
                 s.GetService<ISomeDependency1>(), s.GetService<ISomeDependency2>())));

Assembly.GetEntryAssembly().GetTypesAssignableFrom<IService>().ForEach((t)=>
                {
                    services.AddScoped(typeof(IService), t);
                });

public interface IService
{
    string Name { get; set; }
}

public class ServiceA : IService
{
    public string Name { get { return "A"; } }
}

public class ServiceB : IService
{
    public string Name { get { return "B"; } }
}

public class ServiceC : IService
{
    public string Name { get { return "C"; } }
}

public class MyController
{
    private readonly IEnumerable<IService> _services;
    public MyController(IEnumerable<IService> services)
    {
        _services = services;
    }
    public void DoSomething()
    {
        var service = _services.Where(s => s.Name == "A").Single();
    }
...
}

    public static List<Type> GetTypesAssignableFrom<T>(this Assembly assembly)
    {
        return assembly.GetTypesAssignableFrom(typeof(T));
    }
    public static List<Type> GetTypesAssignableFrom(this Assembly assembly, Type compareType)
    {
        List<Type> ret = new List<Type>();
        foreach (var type in assembly.DefinedTypes)
        {
            if (compareType.IsAssignableFrom(type) && compareType != type)
            {
                ret.Add(type);
            }
        }
        return ret;
    }