MS Unity: Resolve auto-registered types

Question

I'm using MS Unity and 'Registration by convention' (auto-registration) to register all the classes in a namespace. The code (seen below) works at it should and returns an expected result

var container = new UnityContainer();
        container.RegisterTypes( AllClasses.FromLoadedAssemblies().Where(
            t => t.Namespace == "DependencyInjectionExample.Test"), 
            WithMappings.FromMatchingInterface, 
            WithName.Default, 
            WithLifetime.ContainerControlled);

Result

Container has 4 registrations

• IUnityContainer '[default]' Container
• TestClass1 '[default]' ContainerControlled
• TestClass2 '[default]' ContainerControlled
• TestClass3 '[default]' ContainerControlled

My problem is that I can't figure out how to resolve them. I've tried with

var allRegistered = container.ResolveAll<ITestable>();

But it doesn't return anything (all the testclasses implement ITestable). When I try

var singleRegistered = container.Resolve<ITestable>();

I get a 'ResolutionFailedException' - "The type ITestable does not have an accessible constructor". I've read that it is because that the registered types are not named, but that is not possible when using auto-registration.

What should I do to resolve the registered types?

EDIT

namespace DependencyInjectionExample.Test
{
 public interface ITestable
 {
    string SaySomething();
 }
}

One of the three test classes. They all do the same thing.

namespace DependencyInjectionExample.Test
{
 public class TestClass1 : ITestable
 {
    public TestClass1() { }

    public string SaySomething()
    {
        return "TestClass1 hello";
    }
 }
}

Answer 1

I took a closer look at RegisterTypes and it accepts a parameter of the type Func which you can use to provide the name for each instance. There was no need to create an extension to make this happen. After creating the attribute, it was quite easy to provide a specific name to each instance to be registered in the container.

First you create the attribute class:

[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
public sealed class UnityNamedInstanceAttribute : Attribute
{
    private readonly string instanceName;

    public UnityNamedInstanceAttribute(string instanceName)
    {
        this.instanceName = instanceName;
    }

    public string InstanceName
    {
        get { return this.instanceName; }
    }
}

Then set up a class to help with resolving the name of the instance:

public static class UnityNamedInstance
{
    public static string AttributeName(Type type)
    {
        var namedAttribute = type
            .GetCustomAttributes(typeof(UnityNamedInstanceAttribute), true)
            .FirstOrDefault()
            as UnityNamedInstanceAttribute;
        return namedAttribute != null ? namedAttribute.InstanceName : null;
    }

    public static string AttributeNameOrDefault(Type type)
    {
        return UnityNamedInstance.AttributeName(type) ?? WithName.Default(type);
    }
}

Declare your Test Classes using the attribute we created ealier:

public interface ITest
{
    void DebugName();
}

[UnityNamedInstance("Test A")]
public class TestA : ITest
{
    #region ITest Members

    public void DebugName()
    {
        Debug.WriteLine("This is TestA");
    }

    #endregion
}
[UnityNamedInstance("Test B")]
public class TestB : ITest
{
    #region ITest Members

    public void DebugName()
    {
        Debug.WriteLine("This is TestB");
    }

    #endregion
}

[UnityNamedInstance("Test C")]
public class TestC : ITest
{
    #region ITest Members

    public void DebugName()
    {
        Debug.WriteLine("This is TestC");
    }

    #endregion
}

And change your registration by convention method to:

        container.RegisterTypes(
            AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "DependencyInjectionExample.Test"),
            WithMappings.FromAllInterfaces, // This way you have the same instance for each interface the class implements
            UnityNamedInstance.AttributeNameOrDefault, // Use our helper to solve the name of the instance
            WithLifetime.ContainerControlled);

Or you could just avoid creating the attribute and the helper and name the instance after the class name, as follows:

        container.RegisterTypes(
            AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "DependencyInjectionExample.Test"),
            WithMappings.FromAllInterfaces,
            WithName.TypeName, // Use the type name for the instances
            WithLifetime.ContainerControlled);

Now you can access each class instance using the name passed to the attribute constructor in the class declaration or the class name:

        // Access each instance using the name you gave in the attribute
        container.Resolve<ITest>("Test A").DebugName();
        container.Resolve<ITest>("Test B").DebugName();
        container.Resolve<ITest>("Test C").DebugName();

And if you want to get all the registered instances that implements a specific interface:

        foreach (var test in container.Resolve<ITest[]>()) {
            test.DebugName();
        }

OR

        foreach (var test in container.ResolveAll<ITest>()) {
            test.DebugName();
        }

I'm very interested to know if this fits your needs. I appreciate your feedback!

Answer 2

Denis Brat's comment had the critical item in it that helped me solve a problem i had with this.

If you are using a Generic Repository with only constructors that take interfaces the GetInstance methods for the registered types fail with dependancy exceptions.

If you register the interfaces manually BEFORE you auto-register the concrete classes it works, i.e.

ViewModelLocator:

unityContainer.RegisterType(typeof(IGenericRepository<>), typeof(GenericRepository<>));

unityContainer.RegisterTypes(AllClasses.FromAssembliesInBasePath().Where(t => t.Namespace.StartsWith("Mynamespace.")),
            WithMappings.FromAllInterfaces,
            WithName.TypeName,
            WithLifetime.ContainerControlled,null,true);

Model:

public MainViewModel(IGenericRepository<Client> clientRepository, IExceptionManager exceptionManager )
    { whatever }

Views:

return ServiceLocator.Current.GetInstance<MainViewModel>("MainViewModel");

it will find them and return the correct instance.