Castle Windsor ArrayResolver ServiceOverrides Not Respected - castle-windsor

Question

When using the ArrayResolver, if I register multiple dependencies that implement the same interface and I have registered classes that depend on an array of these dependencies, one would expect ServiceOverrides to be respected and allow control over which dependencies are injected into the contructors. Instead, I have seen and written tests that show every dependency is injected into the registered classes contructors.
using System.Linq;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.Resolvers.SpecializedResolvers;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;
using NUnit.Framework;
namespace ServiceFramework.UnitTests
{
public class ArrayResolver_ServiceOverridesNotRespected
{
private class TestInstaller : IWindsorInstaller
{
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(
Component.For<IDependency>().ImplementedBy<Foo>().Named("foo"),
Component.For<IDependency>().ImplementedBy<Bar>().Named("bar"),
Component.For<IDependency>().ImplementedBy<Baz>().Named("baz"),
Component.For<IDependOnArray>().ImplementedBy<DependsOnArray>().Named("InjectAll"),
Component.For<IDependOnArray>().ImplementedBy<DependsOnArray>().Named("InjectFooOnly").ServiceOverrides(
ServiceOverride.ForKey("steps").Eq(new[] {"foo"})),
Component.For<IDependOnArray>().ImplementedBy<DependsOnArray>().Named("InjectFooAndBarOnly").ServiceOverrides(
ServiceOverride.ForKey("steps").Eq(new[] {"foo", "bar"})));
}
}
public interface IDependency
{
}
public class Foo : IDependency
{
}
public class Bar : IDependency
{
}
public class Baz : IDependency
{
}
public interface IDependOnArray
{
IDependency[] GetDependencies();
}
public class DependsOnArray : IDependOnArray
{
private readonly IDependency[] _steps;
public DependsOnArray(IDependency[] steps)
{
_steps = steps;
}
public IDependency[] GetDependencies()
{
return _steps;
}
}
[Test]
public void InjectFooOnly_WithoutArrayResolver()
{
using (var container = new WindsorContainer())
{
container.Install(new TestInstaller());
var fooItemTest = container.Resolve<IDependOnArray>("InjectFooOnly");
var dependencies = fooItemTest.GetDependencies().Select(d => d.GetType()).ToList();
Assert.That(dependencies, Has.Count.EqualTo(1));
Assert.That(dependencies, Has.Member(typeof(Foo)));
}
}
[Test]
[ExpectedException(typeof(AssertionException))]
public void InjectFooOnly_WithArrayResolver()
{
using (var container = new WindsorContainer())
{
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
container.Install(new TestInstaller());
var fooItemTest = container.Resolve<IDependOnArray>("InjectFooOnly");
var dependencies = fooItemTest.GetDependencies().Select(d => d.GetType()).ToList();
Assert.That(dependencies, Has.Count.EqualTo(1));
Assert.That(dependencies, Has.Member(typeof(Foo)));
}
}
[Test]
public void InjectFooAndBarOnly_WithoutArrayResolver()
{
using (var container = new WindsorContainer())
{
container.Install(new TestInstaller());
var fooItemTest = container.Resolve<IDependOnArray>("InjectFooAndBarOnly");
var dependencies = fooItemTest.GetDependencies().Select(d => d.GetType()).ToList();
Assert.That(dependencies, Has.Count.EqualTo(2));
Assert.That(dependencies, Has.Member(typeof(Foo)));
Assert.That(dependencies, Has.Member(typeof(Bar)));
}
}
[Test]
[ExpectedException(typeof(AssertionException))]
public void InjectFooAndBarOnly_WithArrayResolver()
{
using (var container = new WindsorContainer())
{
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
container.Install(new TestInstaller());
var fooItemTest = container.Resolve<IDependOnArray>("InjectFooAndBarOnly");
var dependencies = fooItemTest.GetDependencies().Select(d => d.GetType()).ToList();
Assert.That(dependencies, Has.Count.EqualTo(2));
Assert.That(dependencies, Has.Member(typeof(Foo)));
Assert.That(dependencies, Has.Member(typeof(Bar)));
}
}
[Test]
public void InjectAll()
{
using (var container = new WindsorContainer())
{
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel, true));
container.Install(new TestInstaller());
var fooItemTest = container.Resolve<IDependOnArray>("InjectAll");
var dependencies = fooItemTest.GetDependencies().Select(d => d.GetType()).ToList();
Assert.That(dependencies, Has.Count.EqualTo(3));
Assert.That(dependencies, Has.Member(typeof(Foo)));
Assert.That(dependencies, Has.Member(typeof(Bar)));
Assert.That(dependencies, Has.Member(typeof(Baz)));
}
}
}
}

Answer 1

The issue is now fixed and the fix will be part of the next major version of Windsor.