Unity Register per un'unica interfaccia Più oggetti e comunica unità Dove iniettarli

Question

Ciao Ho avuto problemi nel cercare di dire a Unity che per un'interfaccia se ha più implementazioni, voglio che le iniettino in classi diverse. Ecco cosa Voglio dire:

Diciamo che ho un'interfaccia IProductCatalogService e due implementazioni ProductCatalog : IProductCatalogService e ProductCatalogService : IProductCatalogService.

Come potrei fare per raccontare l'Unità che per la Classe A che voglio nella mia costruttore ha approvato un'istanza di tipo ProductCatalog e per la Classe B voglio un'istanza di ProductCatalogService.

Sto utilizzando Unity in un progetto API Web ASP.NET e ho impostato il resolver nello GLobalConfiguration.

Per semplici registrazioni da 1 a 1 tutto funziona.

Ecco quello che ho provato ma non sembra funzionare:

public class DependencyServiceModel 
{ 
    public Type From { get; set; } 
    public Type To { get; set; } 
    public IEnumerable<Type> ForClasses { get; set; } 
} 

public void RegisterTypeForSpecificClasses(DependencyServiceModel dependencyService) 
{ 
    foreach (var forClass in dependencyService.ForClasses) 
    { 
     string uniquename = Guid.NewGuid().ToString(); 

     Container.RegisterType(dependencyService.From, 
      dependencyService.To, uniquename); 

     Container.RegisterType(forClass, uniquename, 
      new InjectionConstructor(
       new ResolvedParameter(dependencyService.To))); 
    } 
} 

Nel DependencyServiceModel, From è l'interfaccia, To è l'oggetto da strega voglio istanziare e ForClasses sono il tipo per che voglio usare l'oggetto To.

Answer 1

Nell'esempio seguente è stata implementata un'interfaccia due volte e iniettata su richiesta in due diverse classi client, proprio come richiesto. Il trucco è usare le registrazioni nominate.

class Program 
{ 
    static void Main(string[] args) 
    { 
     IUnityContainer container = new UnityContainer(); 
     container.RegisterType<IFoo, Foo1>("Foo1"); 
     container.RegisterType<IFoo, Foo2>("Foo2"); 

     container.RegisterType<Client1>(new InjectionConstructor(new ResolvedParameter<IFoo>("Foo1"))); 
     container.RegisterType<Client2>(new InjectionConstructor(new ResolvedParameter<IFoo>("Foo2"))); 

     Client1 client1 = container.Resolve<Client1>(); 
     Client2 client2 = container.Resolve<Client2>(); 
    } 
} 

public interface IFoo 
{ 

} 

public class Foo1 :IFoo 
{ 

} 

public class Foo2 : IFoo 
{ 

} 

public class Client1 
{ 
    public Client1(IFoo foo) 
    { 

    } 
} 

public class Client2 
{ 
    public Client2(IFoo foo) 
    { 

    } 
} 

Questo è probabilmente ciò che si fa male:

Container.RegisterType(forClass, uniquename, 
     new InjectionConstructor(
      new ResolvedParameter(dependencyService.To))); 

Si crea una registrazione di nome per la classe concreta. Invece si dovrebbe avere

Container.RegisterType(forClass, null, 
     new InjectionConstructor(
      new ResolvedParameter(dependencyService.To, uniquename)));