Question

in my implementation, I have an interface as: ICachingManager. I’ve got now one implementation. I also created a manager class as:

public class CachingManager
{
    #region Members
    private ICachingManager service;
    #endregion

    #region Constructors
    public CachingManager(ICachingManager service)
    {
        this.service = service;
    }
    #endregion

    #region Public Methods
    public void EnCache<T>(string key, T value)
    {
        this.service.EnCache<T>(key, value);
    }

    public T DeCache<T>(string key)
    {
        return this.service.DeCache<T>(key);
    }
    #endregion
}

In case I had one implementation, then I can easily register the CachingManager class with Unity, automatically Unity resolves and injects the ICachingManager.

In case I had more than one implementation using named types, then how can I can make use of Unity? Do I need to make use of an Abstract Factory to decide on which named type to initialize?

Is it a good idea to make use of such a composite class or use directly implementations of the interface with Abstract Factory?

Answer 1

You don’t have to create an abstract factory. You can inject a given named implementation:

public class MyClient
{
    [Dependency("NamedManager")]
    public ICachingManager CachingManager { get; set; }

    // or in the constructor
    public MyClient([Dependency("NamedManager")] ICachingManager cachingManager) {
       // ...
    }
}

or you can configure the container to do the same thing:

public class MyClient
{
    public MyClient(ICachingManager cachingManager) {
       // ...
    }
}
...
void ContainerBuilder() {
   ...
   Container.RegisterType<MyClient>(
       new InjectionConstructor(
          new ResolvedParameter<ICachingManager>("NamedManager")));
   ...
}