城堡温莎ArrayResolver ServiceOverrides不遵守

Question

当使用ArrayResolver，如果我寄存器实现相同的接口的多个依赖关系和我有注册类依赖这些依赖关系在阵列上，可以预期被尊重ServiceOverrides并允许控制哪些依赖关系被注入到构造器中。相反，我已经看到并编写了测试，显示每个依赖项被注入到注册类构造器中。

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

现在问题已经解决，修复程序将成为下一个主要版本的温莎的一部分。