10 Advanced Windsor Tricks – 3. How to resolve arrays

Here’s part three of (at least) 10 Advanced Windsor Tricks.

By default Windsor will not resolve arrays. That is, if you have a number of components registered with the same service, resolving an array of that service will result in an error saying that it cannot satisfy the array dependency.

However there’s a simple solution. Windsor comes with an optional sub-dependency-resolver that can resolve arrays; the ArrayResolver. Here’s how you use it:

First let’s meet our old friends the Things:

public class ThingOne : IThing
{
    public string SayHello(string name)
    {
        return string.Format("ThingOne says hello to {0}", name);
    }
}

public class ThingTwo : IThing
{
    public string SayHello(string name)
    {
        return string.Format("ThingTwo says hello to {0}", name);
    }
}

public class ThingThree : IThing
{
    public string SayHello(string name)
    {
        return string.Format("Hello {0} from ThingThree", name);
    }
}

And here’s a class with a dependency on an array of IThing:

public class UsesThingArray
{
    public IThing[] Things { get; private set; }

    public UsesThingArray(IThing[] things)
    {
        Things = things;
    }
}

I like to wrap the ArrayResolver in a little facility (it would be nice if this was in Windsor), but you don’t have to do this:

public class ArrayFacility : IFacility
{
    public void Init(IKernel kernel, IConfiguration facilityConfig)
    {
        kernel.Resolver.AddSubResolver(new ArrayResolver(kernel));
    }

    public void Terminate(){ }
}

Now you can use fluent registration to register the ArrayFacility and components:

var container = new WindsorContainer()
    .AddFacility<ArrayFacility>()
    .Register(
        AllTypes
            .Of<IThing>()
            .FromAssembly(Assembly.GetExecutingAssembly())
            .WithService.FirstInterface(),
        Component.For<UsesThingArray>()
    );

And finally, this code now works with all three things having their ‘SayHello’ method executed:

var usesThingArray = container.Resolve<UsesThingArray>();
foreach (var thing in usesThingArray.Things)
{
    Console.WriteLine(thing.SayHello("Leo"));
}

The nice thing about this is that if I want to add another element to the array, I simply create a new class that implements IThing which automatically gets registered and handed to UsesThingArray without a single change to any existing code. It’s craftier than a fox who has just graduated from Ruse University with a Degree in cunning!

There is a caveat; the ArrayResolver voids Windsor’s circular dependency detection. See my previous post on this for more detail.