.net - コレクションのさまざまなグループの解決

Question

以下の単体テストでは、MyInterFace[] 配列の 2 つの異なるグループを挿入しようとしていますが、IMyInterface のすべての実装で作成されたインスタンスを取得するため、間違った方法で行っているように見えます。これはかなり非効率的です....

namespace UnitTest.Interface
{
    public interface IMyInterface
    {

    }
}

namespace UnitTest.ArrayGroup1
{
    public class MyInjected1 : IMyInterface
    {
        public static int Instancecount { get; set; }
        public MyInjected1()
        {
            Instancecount++;
        }

    }

    public class MyInjected2 : IMyInterface
    {
        public static int Instancecount { get; set; }
        public MyInjected2()
        {
            Instancecount++;
        }
    }
}

namespace UnitTest.ArrayGroup2
{
    public class MyInjected3 : IMyInterface
    {
        public static int Instancecount { get; set; }
        public MyInjected3()
        {
            Instancecount++;
        }
    }

    public class MyInjected4 : IMyInterface
    {
        public static int Instancecount { get; set; }
        public MyInjected4()
        {
            Instancecount++;
        }
    }
}


namespace UnitTest
{
    public class MyClass1
    {
        private IMyInterface[] collection;
        public MyClass1(IMyInterface[] group1collection)
        {
            collection = group1collection;
        }
    }

    public class MyClass2
    {
        private IMyInterface[] collection;
        public MyClass2(IMyInterface[] group2collection)
        {
            collection = group2collection;
        }
    }

    public class MySubResolver : ISubDependencyResolver
    {
        private readonly IKernel kernel;
        public MySubResolver(IKernel kernel)
        {
            this.kernel = kernel;
        }
        public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
        {
            return dependency.TargetType == typeof(IMyInterface[]);
        }

        public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
        {
            IMyInterface[] res;
            if (dependency.DependencyKey == "group1collection")
                res= kernel.ResolveAll<IMyInterface>().Where(t =>
                {
                    var ns = t.GetType().Namespace;
                    return ns != null && ns.StartsWith("UnitTest.ArrayGroup1");
                }).ToArray();
            else
                res= kernel.ResolveAll<IMyInterface>().Where(t =>
                {
                    var ns = t.GetType().Namespace;
                    return ns != null && ns.StartsWith("UnitTest.ArrayGroup2");
                }).ToArray();
            return res;
        }
    }



    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            var kernel = new DefaultKernel(new DefaultProxyFactory());
            kernel.Resolver.AddSubResolver(new MySubResolver(kernel));    
            var container = new WindsorContainer(kernel, new DefaultComponentInstaller());
            container.Register(
                Classes.FromThisAssembly()
                       .BasedOn<IMyInterface>()
                       .WithServiceFirstInterface()
                       .LifestyleTransient());
            container.Register(Component.For<MyClass1>().LifeStyle.Transient);
            container.Register(Component.For<MyClass2>().LifeStyle.Transient);

            var sut=container.Resolve<MyClass1>();

            Assert.AreEqual(MyInjected1.Instancecount, 1);
            Assert.AreEqual(MyInjected2.Instancecount, 1);
            Assert.AreEqual(MyInjected3.Instancecount, 0);
            Assert.AreEqual(MyInjected4.Instancecount, 0);
        }
    }
}

SubResolver で ResolveAll を呼び出して、本当に必要なクラスのインスタンスのみを作成するにはどうすればよいですか??

ティア

/セーレン

Answer 1

ResolveAll を使用する必要がありますか? 気にしない場合は、サブリゾルバーの Resolve メソッドとして機能します。

    public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
    {
        IMyInterface[] res;
        IHandler[] handlers;

        if (dependency.DependencyKey == "group1collection")
        {
            handlers = kernel.GetHandlers(typeof(IMyInterface)).Where(handler => handler.ComponentModel.Implementation.Namespace.StartsWith("UnitTest.ArrayGroup1")).ToArray();
        }
        else
        {
            handlers = kernel.GetHandlers(typeof(IMyInterface)).Where(handler => handler.ComponentModel.Implementation.Namespace.StartsWith("UnitTest.ArrayGroup2")).ToArray();
        }

        res = new IMyInterface[handlers.Length];
        for (int i = 0; i < res.Length; i++)
        {
            res[i] = handlers[i].Resolve(context) as IMyInterface;
        }

        return res;
    }