blocks|key|258026|text|您应该能够使用ParameterOverrides|type|unstyled|depth|inlineStyleRanges|entityRanges|data|258027|var+repository+=+IOC.Container.Resolve<IRepository>("Client");
var+clientModel+=+IOC.Container.Resolve<ClientModel>(new+ParameterOverrides<ClientModel>+{+{"dataAccess",+repository+}+}+);|code-block|syntax|javascript|258028|编辑:我不确定你为什么要传递UnityContainer+--就我个人而言，我们将依赖注入到构造函数本身中(从我所见，这是“正常的”)。但不管怎样，您都可以在RegisterType和Resolve方法中指定名称。|258029|IOC.Container.RegisterType<IRepository,+GenericRepository>("Client");
IOC.Container.Resolve<IRepository>("Client");|258030|它将为您提供您为该名称注册的类型。|258031|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You should be able to use ParameterOverrides

<pre><code>var repository = IOC.Container.Resolve&lt;IRepository&gt;("Client");
var clientModel = IOC.Container.Resolve&lt;ClientModel&gt;(new ParameterOverrides&lt;ClientModel&gt; { {"dataAccess", repository } } );
</code></pre>

edit:
I'm not sure why you're passing around the UnityContainer - personally, we inject our dependencies into the constructor themselves (which is "normal" from what I've seen). But regardless, you can specify a name in your RegisterType and Resolve methods.

<pre><code>IOC.Container.RegisterType&lt;IRepository, GenericRepository&gt;("Client");
IOC.Container.Resolve&lt;IRepository&gt;("Client");
</code></pre>

and it will give you the type you registered for that name.

blocks|key|255936|text|您可以在API、属性中或通过配置文件配置有名称或无名称的依赖项。您在上面没有提到XML，所以我假定您使用的是API。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|255937|要告诉容器解析命名依赖项，您需要使用InjectionParameter对象。对于您的ClientModel示例，请执行以下操作：|offset|length|style|CODE|255938|container.RegisterType<IClientModel,+ClientModel>(
++++new+InjectionConstructor(++++++++++++++++++++++++//+Explicitly+specify+a+constructor
++++++++new+ResolvedParameter<IRepository>("Client")+//+Resolve+parameter+of+type+IRepository+using+name+"Client"
++++)
);|code-block|syntax|javascript|255939|这将告诉容器“在解析客户端时，调用接受单个IRepository参数的构造函数。在解析该参数时，除了使用类型之外，还要使用名称‘ClientModel’进行解析。”|255940|如果您想使用属性，您的示例几乎可以工作，您只需更改属性名称：|255941|public+ClientModel([Dependency("Client")]+IRepository+dataAccess)
{
+++this.dataAccess+=+dataAccess;

+++.....
}|255942|entityMap^0|0|I|I|17|B|0|0|L|B|1S|B|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

You can configure dependencies with or without names in the API, attributes, or via the config file. You didn't mention XML above, so I'll assume you're using the API.

To tell the container to resolve a named dependency, you'll need to use an <code>InjectionParameter</code> object. For your <code>ClientModel</code> example, do this:

<pre><code>container.RegisterType&lt;IClientModel, ClientModel&gt;(
 new InjectionConstructor( // Explicitly specify a constructor
 new ResolvedParameter&lt;IRepository&gt;("Client") // Resolve parameter of type IRepository using name "Client"
 )
);
</code></pre>

This tells the container "When resolving <code>ClientModel</code>, call the constructor that takes a single <code>IRepository</code> parameter. When resolving that parameter, resolve with the name 'Client' in addition to the type."

If you wanted to use attributes, your example almost works, you just need to change the attribute name:

<pre><code>public ClientModel([Dependency("Client")] IRepository dataAccess)
{
 this.dataAccess = dataAccess;

 .....
}
</code></pre>

blocks|key|261175|text|这是一个很晚的回复，但这个问题仍然出现在谷歌上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261176|所以不管怎样，5年后...|261177|我有一个非常简单的方法。通常，当您需要使用“命名依赖项”时，这是因为您正在尝试实现某种策略模式。在这种情况下，我只是在Unity和我的其余代码之间创建了一个间接级别，称为StrategyResolver，以便不直接依赖Unity。|offset|length|style|CODE|261178|public+class+StrategyResolver+:+IStrategyResolver
{
++++private+IUnityContainer+container;

++++public+StrategyResolver(IUnityContainer+unityContainer)
++++{
++++++++this.container+=+unityContainer;
++++}

++++public+T+Resolve<T>(string+namedStrategy)
++++{
++++++++return+this.container.Resolve<T>(namedStrategy);
++++}
}|code-block|syntax|javascript|261179|用法：|261180|public+class+SomeClass:+ISomeInterface
{
++++private+IStrategyResolver+strategyResolver;

++++public+SomeClass(IStrategyResolver+stratResolver)
++++{
++++++++this.strategyResolver+=+stratResolver;
++++}

++++public+void+Process(SomeDto+dto)
++++{
++++++++IActionHandler+actionHanlder+=+this.strategyResolver.Resolve<IActionHandler>(dto.SomeProperty);
++++++++actionHanlder.Handle(dto);
++++}
}|261181|注册：|261182|container.RegisterType<IActionHandler,+ActionOne>("One");
container.RegisterType<IActionHandler,+ActionTwo>("Two");
container.RegisterType<IStrategyResolver,+StrategyResolver>();
container.RegisterType<ISomeInterface,+SomeClass>();|261183|现在，这样做的好处是，在未来添加新策略时，我再也不用接触StrategyResolver了。|261184|这很简单。非常干净，我把对Unity的依赖严格控制在最低限度。只有当我决定改变容器技术时，我才会接触到StrategyResolver，而这是不太可能发生的。|261185|希望这能有所帮助！|261186|编辑:我真的不喜欢被接受的答案，因为当你在服务的构造函数中使用Dependency属性时，你实际上对Unity有一个硬依赖。Dependency属性是Unity库的一部分。在这一点上，您也可以到处传递一个IUnityContainer依赖项。|261187|我更喜欢让我的服务类依赖于我完全拥有的对象，而不是到处依赖外部库。另外，使用Dependency属性使得构造函数签名变得不那么干净和简单。|261188|此外，此技术允许在运行时解析命名依赖项，而不必在构造函数、应用程序配置文件中或使用InjectionParameter中硬编码命名依赖项，这些方法都需要知道在设计时使用什么命名依赖项。|261189|编辑(2016-09-19)：对于那些可能想知道的人来说，容器将知道在您将IUnityContainer作为依赖项请求时传递自身，如StrategyResolver构造函数签名中所示。|261190|编辑(2018-10-20)：这是另一种方式，简单地使用工厂：|261191|public+class+SomeStrategyFactory+:+ISomeStrategyFactory
{
++++private+IStrategy+_stratA;
++++private+IStrategy+_stratB;

++++public+SomeFactory(IStrategyA+stratA,+IStrategyB+stratB)
++++{
++++++++_stratA+=+stratA;
++++++++_stratB+=+stratB;
++++}

++++public+IStrategy+GetStrategy(string+namedStrategy){
++++++++if+(namedStrategy+==+"A")+return+_stratA;
++++++++if+(namedStrategy+==+"B")+return+_stratB;
++++}
}

public+interface+IStrategy+{
++++void+Execute();
}

public+interface+IStrategyA+:+IStrategy+{}

public+interface+IStrategyB+:+IStrategy+{}

public+class+StrategyA+:+IStrategyA+{
++++public+void+Execute(){}
}

public+class+StrategyB+:+IStrategyB+{
++++public+void+Execute()+{}
}|261192|261193|public+class+SomeClass+:+ISomeClass
{
++++public+SomeClass(ISomeStrategyFactory+strategyFactory){

++++++++IStrategy+strat+=+strategyFactory.GetStrategy("HelloStrategy");
++++++++strat.Execute();

++++}
}|261194|261195|container.RegisterType<ISomeStrategyFactory,+SomeStrategyFactory>();
container.RegisterType<IStrategyA,+StrategyA>();
container.RegisterType<IStrategyB,+StrategyB>();
container.RegisterType<ISomeClass,+SomeClass>();|261196|第二个建议是一样的，但是使用了工厂设计模式。|261197|261198|entityMap^0|0|0|2D|G|0|0|0|0|0|0|0|0|0|V|A|1Q|A|2U|F|0|12|A|0|15|I|0|11|F|1U|G|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1R|8|@$F|1S|G|1T|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1U|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1V|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1W|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1X|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1Y|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|20|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|21|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|22|8|@$F|23|G|24|H|I]|$F|25|G|26|H|I]|$F|27|G|28|H|I]]|9|@]|A|$]]|$1|14|3|15|5|6|7|29|8|@$F|2A|G|2B|H|I]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2C|8|@$F|2D|G|2E|H|I]]|9|@]|A|$]]|$1|18|3|19|5|6|7|2F|8|@$F|2G|G|2H|H|I]|$F|2I|G|2J|H|I]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|L|7|2L|8|@]|9|@]|A|$M|N]]|$1|1E|3|P|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|L|7|2N|8|@]|9|@]|A|$M|N]]|$1|1H|3|T|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|L|7|2P|8|@]|9|@]|A|$M|N]]|$1|1K|3|1L|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1M|3|11|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]]|1O|$]]

This is a very late response but the question still shows up in Google.

So anyways, 5 years later...

I have a pretty simple approach. Usually when you need to use "named dependency" it's because you're trying to implement some kind of strategy pattern. In that case, I simply create a level of indirection between Unity and the rest of my code called the <code>StrategyResolver</code> to not be directly depending on Unity.

<pre><code>public class StrategyResolver : IStrategyResolver
{
 private IUnityContainer container;

 public StrategyResolver(IUnityContainer unityContainer)
 {
 this.container = unityContainer;
 }

 public T Resolve&lt;T&gt;(string namedStrategy)
 {
 return this.container.Resolve&lt;T&gt;(namedStrategy);
 }
}
</code></pre>

Usage:

<pre><code>public class SomeClass: ISomeInterface
{
 private IStrategyResolver strategyResolver;

 public SomeClass(IStrategyResolver stratResolver)
 {
 this.strategyResolver = stratResolver;
 }

 public void Process(SomeDto dto)
 {
 IActionHandler actionHanlder = this.strategyResolver.Resolve&lt;IActionHandler&gt;(dto.SomeProperty);
 actionHanlder.Handle(dto);
 }
}
</code></pre>

Registration:

<pre><code>container.RegisterType&lt;IActionHandler, ActionOne&gt;("One");
container.RegisterType&lt;IActionHandler, ActionTwo&gt;("Two");
container.RegisterType&lt;IStrategyResolver, StrategyResolver&gt;();
container.RegisterType&lt;ISomeInterface, SomeClass&gt;();
</code></pre>

Now, the nice thing about this is that I will never have to touch the StrategyResolver ever again when adding new strategies in the future.

It's very simple. Very clean and I kept the dependency on Unity to a strict minimum. The only time I would have touch the StrategyResolver is if I decide to change container technology which is very unlikely to happen.

Hope this helps!

Edit: I don't really like the accepted answer because when you use the <code>Dependency</code> attribute in your service's constructor you actually have a hard dependency on Unity. The <code>Dependency</code> attribute is part of the Unity library. At that point you might as well pass an <code>IUnityContainer</code> dependency everywhere.

I prefer having my service classes depend on objects that I completely own instead of having a hard dependency on an external library all over the place. Also using <code>Dependency</code> attribute makes the constructors signatures less clean and simple.

Furthermore, this technique allows to resolve named dependencies at runtime without having to hardcode the named dependencies in the constructor, in the application configuration file or use <code>InjectionParameter</code> which are all methods that require to know what named dependency to use at design time.

Edit (2016-09-19): 
For those that might wonder, the container will know to pass itself when you are requesting <code>IUnityContainer</code> as dependency, as shown in the <code>StrategyResolver</code> constructor signature.

Edit (2018-10-20):
Here's another way, simply using a factory:

<pre><code>public class SomeStrategyFactory : ISomeStrategyFactory
{
 private IStrategy _stratA;
 private IStrategy _stratB;

 public SomeFactory(IStrategyA stratA, IStrategyB stratB)
 {
 _stratA = stratA;
 _stratB = stratB;
 }

 public IStrategy GetStrategy(string namedStrategy){
 if (namedStrategy == "A") return _stratA;
 if (namedStrategy == "B") return _stratB;
 }
}

public interface IStrategy {
 void Execute();
}

public interface IStrategyA : IStrategy {}

public interface IStrategyB : IStrategy {}

public class StrategyA : IStrategyA {
 public void Execute(){}
}

public class StrategyB : IStrategyB {
 public void Execute() {}
}
</code></pre>

Usage:

<pre><code>public class SomeClass : ISomeClass
{
 public SomeClass(ISomeStrategyFactory strategyFactory){

 IStrategy strat = strategyFactory.GetStrategy("HelloStrategy");
 strat.Execute();

 }
}
</code></pre>

Registration:

<pre><code>container.RegisterType&lt;ISomeStrategyFactory, SomeStrategyFactory&gt;();
container.RegisterType&lt;IStrategyA, StrategyA&gt;();
container.RegisterType&lt;IStrategyB, StrategyB&gt;();
container.RegisterType&lt;ISomeClass, SomeClass&gt;();
</code></pre>

This 2nd suggestion is the same thing but using the factory design pattern.

Hope this helps!

blocks|key|255963|text|不要这样做-只需创建一个class+ClientRepository+:+GenericRepository+{+}并利用类型系统即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|255964|entityMap^0|C|1A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Don't do this - just create a <code>class ClientRepository : GenericRepository { }</code> and utilise the Type system.

I have the <code>IRespository</code> registered twice (with names) in the following code:

<pre><code>// Setup the Client Repository
IOC.Container.RegisterType&lt;ClientEntities&gt;(new InjectionConstructor());
IOC.Container.RegisterType&lt;IRepository, GenericRepository&gt;
 ("Client", new InjectionConstructor(typeof(ClientEntities)));

// Setup the Customer Repository
IOC.Container.RegisterType&lt;CustomerEntities&gt;(new InjectionConstructor());
IOC.Container.RegisterType&lt;IRepository, GenericRepository&gt;
 ("Customer", new InjectionConstructor(typeof(CustomerEntities)));

IOC.Container.RegisterType&lt;IClientModel, ClientModel&gt;();
IOC.Container.RegisterType&lt;ICustomerModel, CustomerModel&gt;();
</code></pre>

But then when I want to resolve this (to use the <code>IRepository</code>) I have to do a manual resolve like this:

<pre><code>public ClientModel(IUnityContainer container)
{
 this.dataAccess = container.Resolve&lt;IRepository&gt;(Client);

 .....
}
</code></pre>

What I would like to do is to have it resolved in the constructor (just like <code>IUnityContainer</code>). I need some way to say which named type to resolve to.

Something like this: (NOTE: Not real code)

<pre><code>public ClientModel([NamedDependancy("Client")] IRepository dataAccess)
{
 this.dataAccess = dataAccess;

 .....
}
</code></pre>

Is there a way to make my fake code work?

With Unity how do I inject a named dependency into a constructor?

容器

我在下面的代码中注册了两次IRespository (带有名称)：// Setup the Client RepositoryIOC.Container.RegisterType<ClientEntities>(new InjectionConstructor());IOC.Container.RegisterType...

问使用Unity，我如何将命名依赖注入到构造函数中？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Unity，我如何将命名依赖注入到构造函数中？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Unity，我如何将命名依赖注入到构造函数中？
EN