DI con Unity quando occorrono più istanze dello stesso tipo

Question

Ho bisogno di aiuto con questo. Sto usando Unity come contenitore e voglio iniettare due diverse istanze dello stesso tipo nel mio costruttore.

class Example 
{ 
    Example(IQueue receiveQueue, IQueue sendQueue) {} 
} 

.... e iQueue è implementato nella mia classe MessageQueue ....

class MessageQueue : IQueue 
{ 
    MessageQueue(string path) {} 
} 

Come posso iniettare due diverse istanze di MessageQueue nella mia classe di esempio? Ciascuna istanza di MessageQueue da creare con un percorso diverso.

Answer 1

è possibile registrare le due istanze con i nomi:

myContainer.RegisterInstance<IQueue>("ReceiveQueue", myReceiveMessageQueue); 
myContainer.RegisterInstance<IQueue>("SendQueue", mySendMessageQueue); 

e allora si dovrebbe essere in grado di risolvere in base al nome, ma richiede l'utilizzo dell'attributo Dependency:

class Example 
{ 
    Example([Dependency("ReceiveQueue")] IQueue receiveQueue, 
      [Dependency("SendQueue")] IQueue sendQueue) { 
    } 
} 

o iniettare la unità container e quindi risolvere le istanze all'interno del costruttore:

class Example 
{ 
    Example(IUnityContainter container) 
    { 
     _receiveQueue = container.Resolve<IQueue>("ReceiveQueue"); 
     _sendQueue = container.Resolve<IQueue>("SendQueue"); 
    } 
} 

Answer 2

Penso che questo sia stato chiesto prima su Stackoverflow. È necessario utilizzare ParameterOverride:

ParameterOverride consente di passare in valori per i parametri del costruttore per sovrascrivere un parametro passato a un determinato costruttore denominato. Solo il valore del parametro è sovrascritto, non il costruttore.

Link to MSDN Article

Link to Stackoverflow Article

var exampleInstance = new Example(); 

var queue1 = unityContainer.Resolve<IQueue>(new ParameterOverrides<MessageQueue> { { "path", "yourPath" }}); 

var queue2 = unityContainer.Resolve<IQueue>(new ParameterOverrides<MessageQueue> { { "path", "yourPath2Queue2" }}); 

exampleInstance.Example(queue1,queue2); 

Answer 3

bene, non

è necessario utilizzare il modello di fabbrica in questo caso.

class Example 
{ 
    Example(IQueueFactory factory) 
    { 
     _sendQueue = factory.Create("MySend"); 
     _receiveQueue = factory.Create("MyReceive"); 
    } 
} 

Si fa l'intenzione molto più chiara e si può internamente nel manico Example classe se le code sono non trovato o configurato in modo errato.

Answer 4

Non tutto deve essere automaticamente collegato al container. È possibile registrare la classe Example in questo modo:

container.Register<Example>(new InjectionFactory(c => 
{ 
    var receive = new MessageQueue("receivePath"); 
    var send = new MessageQueue("sendPath"); 
    return new Example(receive, send); 
}); 

Answer 5

Ci sono molti modi per raggiungere i risultati desiderati (come evidenziato dalle risposte multiple). Ecco un altro modo con le registrazioni di nome (senza attributi):

IUnityContainer container = new UnityContainer(); 

container.RegisterType<IQueue, MessageQueue>("ReceiveQueue", 
    new InjectionConstructor("receivePath")); 

container.RegisterType<IQueue, MessageQueue>("SendQueue", 
    new InjectionConstructor("sendPath")); 

container.RegisterType<Example>(
    new InjectionConstructor(
     new ResolvedParameter<IQueue>("ReceiveQueue"), 
     new ResolvedParameter<IQueue>("SendQueue"))); 

Example example = container.Resolve<Example>(); 

Lo svantaggio di questo approccio è che se il costruttore Esempio è cambiato quindi il codice di registrazione deve essere modificato per corrispondere. Inoltre, l'errore sarebbe un errore di runtime e non un errore di compilazione più preferibile.

È possibile combinare quanto sopra con un'InjectionFactory per invocare il costruttore manualmente per dare tempo di compilazione controllo:

IUnityContainer container = new UnityContainer(); 

container.RegisterType<IQueue, MessageQueue>("ReceiveQueue", 
    new InjectionConstructor("receivePath")); 

container.RegisterType<IQueue, MessageQueue>("SendQueue", 
    new InjectionConstructor("sendPath")); 

container.RegisterType<Example>(new InjectionFactory(c => 
    new Example(c.Resolve<IQueue>("ReceiveQueue"), 
       c.Resolve<IQueue>("SendQueue")))); 

Example example = container.Resolve<Example>(); 

Se si utilizza una radice composizione allora l'uso delle corde magiche ("ReceiveQueue" e " SendQueue ") sarebbe limitato all'unica posizione di registrazione.