With Unity, how do I insert a named dependency in a constructor?

Question

I have an IRespository registered twice (with names) in the following code:

 // Setup the Client Repository IOC.Container.RegisterType<ClientEntities>(new InjectionConstructor()); IOC.Container.RegisterType<IRepository, GenericRepository> ("Client", new InjectionConstructor(typeof(ClientEntities))); // Setup the Customer Repository IOC.Container.RegisterType<CustomerEntities>(new InjectionConstructor()); IOC.Container.RegisterType<IRepository, GenericRepository> ("Customer", new InjectionConstructor(typeof(CustomerEntities))); IOC.Container.RegisterType<IClientModel, ClientModel>(); IOC.Container.RegisterType<ICustomerModel, CustomerModel>(); 

But then, when I want to solve this problem (use IRepository ), I have to execute a manual solution like this:

 public ClientModel(IUnityContainer container) { this.dataAccess = container.Resolve<IRepository>(Client); ..... } 

What I would like to do is enable it in the constructor (same as IUnityContainer ). I need some way to tell which named type to allow.

Something like this: (NOTE: not a real code)

 public ClientModel([NamedDependancy("Client")] IRepository dataAccess) { this.dataAccess = dataAccess; ..... } 

Is there a way to make my fake code work?

Answer 1

You can configure dependencies with or without names in the API, attributes, or through the configuration file. You did not mention XML above, so I assume you are using the API.

To tell the container to allow a named dependency, you need to use the InjectionParameter object. For your ClientModel example ClientModel do this:

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

This tells the container: "When resolving the ClientModel call a constructor that accepts one IRepository parameter. When resolving this parameter, the IRepository with the name" Client "in addition to the type."

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

 public ClientModel([Dependency("Client")] IRepository dataAccess) { this.dataAccess = dataAccess; ..... } 

Answer 2

This is a very late answer, but the question still appears on Google.

One way or another, 5 years later ...

I have a pretty simple approach. Usually, when you need to use a "named dependency" because you are trying to implement some kind of strategy template. In this case, I simply create a level of indirection between Unity and the rest of my code called StrategyResolver so as not to depend directly on 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); } } 

Using:

 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); } } 

Registration:

 container.RegisterType<IActionHandler, ActionOne>("One"); container.RegisterType<IActionHandler, ActionTwo>("Two"); container.RegisterType<IStrategyResolver, StrategyResolver>(); container.RegisterType<ISomeInterface, SomeClass>(); 

Now the good thing is that I will never have to touch StrategyResolver again when adding new strategies in the future.

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

Hope this helps!

Edit: I don't really like the accepted answer, because when you use the Dependency attribute in the service designer, you are actually very dependent on Unity. The Dependency attribute is part of the Unity library. At this point, you can also pass the IUnityContainer dependency everywhere.

I prefer that my service classes depend on objects that I fully own, rather than having a tight dependency on an external library everywhere. Also, the use of the Dependency attribute makes constructor signatures less clear and simple.

In addition, this method allows you to resolve named dependencies at run time without having to hard-code the named dependencies in the constructor, in the application configuration file, or use the InjectionParameter which are all methods that require you to know which named dependency to use at design time.

Editing (2016-09-19): for those who may wonder, the container will know that it will skip itself when you request the IUnityContainer as a dependency, as shown in the signature of the StrategyResolver constructor.

Edit (2018-10-20): here is another way, just using the factory:

 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() {} } 

Using:

 public class SomeClass : ISomeClass { public SomeClass(ISomeStrategyFactory strategyFactory){ IStrategy strat = strategyFactory.GetStrategy("HelloStrategy"); strat.Execute(); } } 

Registration:

 container.RegisterType<ISomeStrategyFactory, SomeStrategyFactory>(); container.RegisterType<IStrategyA, StrategyA>(); container.RegisterType<IStrategyB, StrategyB>(); container.RegisterType<ISomeClass, SomeClass>(); 

This second sentence is the same, but using a factory design template.

Hope this helps!

Answer 3

You should be able to use ParameterOverrides

 var repository = IOC.Container.Resolve<IRepository>("Client"); var clientModel = IOC.Container.Resolve<ClientModel>(new ParameterOverrides<ClientModel> { {"dataAccess", repository } } ); 

edit: I'm not sure why you are walking around the UnityContainer - personally, we embed our dependencies in the constructor itself (which is the "normal" from what I saw). But independently, you can specify a name in the RegisterType and Resolve methods.

 IOC.Container.RegisterType<IRepository, GenericRepository>("Client"); IOC.Container.Resolve<IRepository>("Client"); 

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

Answer 4

Don't do this - just create a class ClientRepository: GenericRepository { } and use a type system.