Injecting an array of objects with Unity

Jon Dalberg — Tue, 20 Oct 2009 03:56:19 GMT

If you only have one implementation of a registered interface then it is pretty straight forward, but what do you do if you have multiple implementations of an interface? Now you have to get a little more explicit when registering items in your container. Let’s go through a simple example.

Say you have a class, OrderProcessor, that takes one implementation of IMessageWriter:

    public class OrderProcessor

        private readonly IMessageWriter _messageWriter;

        public OrderProcessor(IMessageWriter messageWriter)

            _messageWriter = messageWriter;

        public void SubmitOrder()

            // do something special with the order

            _messageWriter.Write("Submitting order...");

            // do some more with the order

IMessageWriter is a simple interface:

    public interface IMessageWriter

        void Write(string message);

If we have only one implementation of IMessageWriter then registration is simple:

    class Program

        static void Main(string[] args)

            var container = new UnityContainer();

            container.RegisterType<IMessageWriter, ConsoleMessageWriter>();

            var orderProcessor = container.Resolve<OrderProcessor>();

            orderProcessor.SubmitOrder();

In this case our OrderProcessor will use the ConsoleMessageWriter when we call SubmitOrder to write the message to the console. Here’s the implementation of ConsoleMessageWriter:

    public class ConsoleMessageWriter : IMessageWriter

        public void Write(string message)

            Console.WriteLine(message);

What if we have two implementations of IMessageWriter? Let’s add DebugMessageWriter:

    public class DebugMessageWriter : IMessageWriter

        public void Write(string message)

            Debug.WriteLine(message);

And when we register both types with our IoC container, which one will be used?

    class Program

        static void Main(string[] args)

            var container = new UnityContainer();

            container.RegisterType<IMessageWriter, ConsoleMessageWriter>();

            container.RegisterType<IMessageWriter, DebugMessageWriter>();

            var orderProcessor = container.Resolve<OrderProcessor>();

            orderProcessor.SubmitOrder();

That’s right – the only one called will be the DebugMessageWriter implementation! The last one registered wins.

Now let’s say you change your mind and decide to accept all the registered implementations of IMessageWriter:

    public class OrderProcessor

        private readonly IMessageWriter[] _messageWriters;

        public OrderProcessor(IMessageWriter[] messageWriters)

            _messageWriters = messageWriters;

        public void SubmitOrder()

            // do something special with the order

            foreach (var writer in _messageWriters)

                writer.Write("Submit order...");

            // do some more with the order

Which implementation will be used? Neither. How can you get the container to use your implementations? It ends up you have to give each registered implementation a unique name, like this:

    class Program

        static void Main(string[] args)

            var container = new UnityContainer();

            container.RegisterType<IMessageWriter, ConsoleMessageWriter>("console");

            container.RegisterType<IMessageWriter, DebugMessageWriter>("debug");

            var orderProcessor = container.Resolve<OrderProcessor>();

            orderProcessor.SubmitOrder();

Now when you run the code both implementations will be called. This was not really clear to me when I started working with Unity so I hope this clears up some fog for others.

Enjoy!

Unity Convention Based Registration

Jon Dalberg — Tue, 29 Sep 2009 02:35:11 GMT

Maybe it is just me, but I’m not a big fan of huge amounts of XML configuration. I can get by with a few name-value pairs in an app.config or a web.config but much more makes me nervous that I’m going to mistype something and not know about it until run time. I’ve been using Unity and it has the ability to load up its configuration from the app.config or web.config. Here’s a sample:

Yeah…..what else ya got?

It offers a “fluent” API for programmatic registration. Sweet! Now I just have to convert all that XML into code. Hmmmm…Now I have a whole lotta

Container.RegisterType<IMyThing, MyThing>();

That works for a trivial class but I don’t want to write a bunch of repetitive code that simply registers interfaces for types. StructureMap has some sort of convention based registration, why not Unity? Let’s get busy…

To start off I’ll add a few extension methods to make life a bit easier:

    public static class ExtensionMethods
    {
        public static IEnumerable<Type> GetInterfaces(this Assembly assembly)
        {
            return assembly.GetTypes().Where(t => t.IsInterface);
        }

        public static IList<Type> GetImplementationsOfInterface(this Assembly assembly, Type interfaceType)
        {
            var implementations = new List<Type>();

            var concreteTypes = assembly.GetTypes().Where(t =>
                !t.IsInterface &&
                !t.IsAbstract &&
                interfaceType.IsAssignableFrom(t));

            concreteTypes.ToList().ForEach(implementations.Add);

            return implementations;
        }

        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
        {
            foreach (var item in enumerable)
            {
                action(item);
            }
        }
    }

These just offer some shortcuts for getting all the interface from an assembly and then finding all the types which implement a given interface in an assembly. Now we can use these to find and register our interfaces and implementations in our ConventionRegistrar:

    public class ConventionRegistrar
    {
        public static void Configure(IUnityContainer container)
        {
            var asm = Assembly.GetExecutingAssembly();

            var interfaces = asm.GetInterfaces();

            foreach (var interfaceType in interfaces)
            {
                var currentInterfaceType = interfaceType;

                var implementations = asm.GetImplementationsOfInterface(interfaceType);

                if (implementations.Count > 1)
                    implementations.ToList().ForEach(i => container.RegisterType(currentInterfaceType, i, i.Name));
                else
                    implementations.ToList().ForEach(i => container.RegisterType(currentInterfaceType, i));
            }
        }
    }

I have this one hard coded to use the executing assembly, but that could easily be changed. Essentially, this just looks up the interfaces then finds all the types that implement those interfaces. The only funky part is where I check if more than one type implements an interface. If that is the case I want to register it as a “named” type, otherwise Unity will only keep the last one registered. This way I can have multiple types implement an interface and get them all by calling

var startupTasks = Container.ResolveAll<IStartupTask>();

That will give me an array of all the classes that implement the IStartupTask interface. So now instead of all that XML or those repetitive Container.Register<I, T>() calls I can simple call ConventionRegistrar.Configure(Container) and most of my work is done. Sure, I may have to do some custom registration for special cases but I’ve taken care of the tedious registration tasks.

Enjoy!