IEnumerable Unity Injection

A few years ago I blogged about how to add Lazy Unity Injection, and then a year after that Unity 3 added that feature. Recently I had to dust off this old code to do something similar...

I wanted to use Unity to inject a collection of registered types into one of my services. To do this directly from the container you would use named registrations and ResolveAll. However if you just try to resolve an IEnumerable of a type in a constructor, then Unity will just try to use Resolve and thus throw an InvalidOperationException.

We can easily "fix" this by registering an extension with our container.

Extension

public class EnumerableContainerExtension : UnityContainerExtension

{

    protected override void Initialize()

    {

        Context.Policies.Set<IBuildPlanPolicy>(

            new EnumerableBuildPlanPolicy(),

            typeof(IEnumerable<>));

    }

    private class EnumerableBuildPlanPolicy : IBuildPlanPolicy

    {

        public void BuildUp(IBuilderContext context)

        {

            if (context.Existing != null)

                return;

            var container = context.NewBuildUp<IUnityContainer>();

            var typeToBuild = context.BuildKey.Type.GetGenericArguments()[0];

            context.Existing = container.ResolveAll(typeToBuild);

            DynamicMethodConstructorStrategy.SetPerBuildSingleton(context);

        }

    }

}

Ambiguous Invocation from Optional Parameter Overloads

There are many reasons for your C# compiler to give you an ambiguous invocation error. When using optional arguments you have to be sure not to create an overload that have overlapping optional parameters. Let's take a look:

public void DoStuff(int i, object o = null) { }

public void DoStuff(int i, string s = null) { }

public void DoStuff(int i, string s = null, bool b = false) { }

public void Test()

{

    // Ambiguous invocation!

    DoStuff(1);

}

There is no need to create methods like the ones shown above!

Instead consider that there is no reason to have two overloads being called with the potentially the same parameters. Such overloads should be combine into one method, and other overloads with different types argument can just be written as normal parameters without default values. Again, let's take a look:

public void DoStuff(int i, object o) { }

public void DoStuff(int i, string s = null, bool b = false) { }

public void Test()

{

    // No more ambiguous invocation :)

    DoStuff(1);

}

I hope that helps,
Tom

Create objects from default constructor

Do you think that title sound redundant? If so, which method were you thinking of? Because there are several! Let's talk about those...and be sure to scroll to the bottom for a performance comparison!

Sample Class

Here is the class that we will be instantiating in our tests.

internal class TestClass

{

    public Guid Guid { get; private set; }

    public TestClass()

    {

        Guid = Guid.NewGuid();

    }

}

The new Keyword

This is the obviously, easier, fastest, normal way of instantiating an object...obviously.

[Fact]

public void NewDuh()

{

    var testObject = new TestClass();

    Assert.NotNull(testObject.Guid);

}

Activator.CreateInstance

This is a very simple and common way to instantiate an object from a Type object. It has an overload that takes a params object collection to let you use other, non default, constructors.

[Fact]

public void ActivatorCreateInstance()

{

    var type = typeof (TestClass);

    var instance = Activator.CreateInstance(type);

    var testObject = Assert.IsType<TestClass>(instance);

    Assert.NotNull(testObject.Guid);

}