DI mit der Einheit, wenn mehrere Instanzen der gleichen Art gebraucht wird

Ihnen konnten sich die zwei Instanzen mit den Namen:

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

und dann sollte man lösen können, indem Namen, aber es erfordert die Verwendung der Dependency Attribut:

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

oder Spritzen Sie den unity-container und lösen dann die Instanzen innerhalb der Konstruktor:

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

Gut, nicht

Sollten Sie die factory-Muster in diesem Fall.

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

Macht es die Absicht, viel mehr klar und können Sie intern in der Example Klasse behandeln, wenn die Warteschlangen werden nicht gefunden oder falsch konfiguriert ist.

5 Jahre später, aber ich war auf der Suche nach dieser Antwort zu.
Ich arbeitete durch Sie mit meinem eigenen code, und dann beschlossen, zum erstellen von funktionierenden code mit (leicht verändert) Klassen der OP zur Verfügung gestellt.

Dies ist ein ganzes Beispiel arbeiten, die Sie kopieren können in LINQPad (programmer ' s playground) und ausführen.

Using-Anweisung /Einheit Libary

Müssen Sie fügen Sie einen Verweis zu Microsoft.Practices.Unity.dll
Müssen Sie auch fügen Sie eine using-Anweisung von :

Microsoft.Practices.Unity

In LinqPad drücken Sie F4, um den Verweis hinzuzufügen und die using-Anweisung (namespace importieren).

void Main()
{
    //Create your unity container (one-time creation)
    UnityContainer uc = new UnityContainer();

    //Create simple list to hold your target objects
    //(makes the sample easy to follow)
    List<MessageQueue> allMQs = new List<MessageQueue>();

    //I'm adding TransientLifetimeManager() in order to 
    //explicitly ask for new object creation each time
    //uc.Resolve<MessageQueue>() is called
    uc.RegisterType<IQueue, MessageQueue>(new TransientLifetimeManager());
//### override the parameters by matching the parameter name (inPath)
    var item = uc.Resolve<MessageQueue>(new ParameterOverride("inPath", "extra.txt").OnType<MessageQueue>());
    allMQs.Add(item);
    item = uc.Resolve<MessageQueue>(new ParameterOverride("inPath", "super.txt").OnType<MessageQueue>());
    allMQs.Add(item);

    foreach (MessageQueue mq in allMQs){
        Console.WriteLine($"mq.Path : {mq.Path}");
    }

    Console.WriteLine("######################\n");

    uc.RegisterType<Example>(new InjectionConstructor((allMQs[0] as IQueue),(allMQs[1] as IQueue)));

    //#### Create a new Example from the UnityContainer
    var example1 = uc.Resolve<Example>();
    //##### Notice that the Example object uses the default values of super.txt & extra.txt

    Console.WriteLine("#### example1 obj. uses default values ###########");
    Console.WriteLine($"example1.receiver.Path : {example1.receiver.Path}");
    Console.WriteLine($"example1.sender.Path : {example1.sender.Path}");

    //##################################################
    //Override the parameters that he Example class uses.
 //### override the parameters by matching the parameter 
 //names (receiveQueue, sendQueue) found in the target
//class constructor (Example class)
    var example2 = uc.Resolve<Example>( 
        new ParameterOverrides {
             {"receiveQueue", new MessageQueue("newReceiveFile")},
             { "sendQueue", new MessageQueue("newSendFile")}
        }.OnType<Example>());

    Console.WriteLine("######################\n");

    Console.WriteLine("#### example1 obj. uses ParameterOverride values ###########");
    Console.WriteLine($"example2.sender.Path : {example2.sender.Path}");
    Console.WriteLine($"example2.receiver.Path : {example2.receiver.Path}");
}

class Example
{
   public MessageQueue receiver {get;set;}
   public MessageQueue sender {get;set;}

   public Example(IQueue receiveQueue, IQueue sendQueue) {
    this.receiver = receiveQueue as MessageQueue;
    this.sender = sendQueue as MessageQueue;

   }
}

public class MessageQueue : IQueue
{
    public string Path {get;set;}
    public MessageQueue(string inPath) {
        Path = inPath;}
}

interface IQueue{

}

Ausgabe Für Prüfung

Wenn Sie das Skript ausführen oben sehen Sie Beispiel-Ausgabe, welche wie folgt Aussehen:

mq.Path : extra.txt
mq.Path : super.txt
######################

#### example1 obj. uses default values ###########
example1.receiver.Path : extra.txt
example1.sender.Path : super.txt
######################

#### example1 obj. uses ParameterOverride values ###########
example2.sender.Path : newSendFile
example2.receiver.Path : newReceiveFile