这是一个很晚的回复，但问题仍然出现在 Google 中。
所以无论如何，5年后......
我有一个非常简单的方法。通常，当您需要使用“命名依赖项”时，这是因为您正在尝试实现某种策略模式。在这种情况下，我只是在 Unity 和称为 StrategyResolver 的其余代码之间创建一个间接级别，以不直接依赖于 Unity。
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);
}
}
用法：
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);
}
}
注册：
container.RegisterType<IActionHandler, ActionOne>("One");
container.RegisterType<IActionHandler, ActionTwo>("Two");
container.RegisterType<IStrategyResolver, StrategyResolver>();
container.RegisterType<ISomeInterface, SomeClass>();
现在，这样做的好处是，我以后在添加新策略时再也不用碰 StrategyResolver。
这很简单。非常干净，我将对 Unity 的依赖保持在最低限度。我唯一会接触 StrategyResolver 的情况是，如果我决定更改容器技术，这不太可能发生。
希望这会有所帮助！
编辑：我不太喜欢接受的答案，因为当您在服务的构造函数中使用 Dependency 属性时，您实际上对 Unity 有一个硬依赖。 Dependency 属性是 Unity 库的一部分。到那时，你不妨到处传递一个 IUnityContainer 依赖项。
我更喜欢让我的服务类依赖于我完全拥有的对象，而不是完全依赖于整个地方的外部库。还使用Dependency 属性使构造函数签名不那么干净和简单。
此外，此技术允许在运行时解析命名依赖项，而无需在构造函数、应用程序配置文件中硬编码命名依赖项或使用InjectionParameter，这些方法都需要知道在设计时使用什么命名依赖项时间。
编辑（2016-09-19）：
对于那些可能想知道的人，当您请求 IUnityContainer 作为依赖项时，容器会知道传递自己，如 StrategyResolver 构造函数签名所示。
编辑（2018-10-20）：
这是另一种方式，只需使用工厂：
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() {}
}
用法：
public class SomeClass : ISomeClass
{
public SomeClass(ISomeStrategyFactory strategyFactory){
IStrategy strat = strategyFactory.GetStrategy("HelloStrategy");
strat.Execute();
}
}
注册：
container.RegisterType<ISomeStrategyFactory, SomeStrategyFactory>();
container.RegisterType<IStrategyA, StrategyA>();
container.RegisterType<IStrategyB, StrategyB>();
container.RegisterType<ISomeClass, SomeClass>();
第二条建议是相同的，但使用工厂设计模式。
希望这会有所帮助！