Dependency injection Castle Windsor ChildContainer依赖项解析

我正在使用温莎城堡，以下是我想要做的

ParentContainer

具有

CarFactory

这取决于抽象

WheelFactory

，但是

WheelFactory

将在子容器1和2中注册

ChildContainer 1

具有

WheelFactory

作为

BigWheelFactory

ChildContainer 2

具有

WheelFactory

作为

SmallWheelFactory

现在我们有了

[ParentContainer（ChildContainer 1，ChildContainer 2）]

线程1仅使用

ChildContainer 1

线程2仅使用

ChildContainer 2

线程1从

ChildContainer 1

请求

CarFactory

，在这种情况下，汽车工厂应使用

BigWheelFactory

线程2从

ChildContainer 2

请求

CarFactory

，在这种情况下，汽车工厂应使用

SmallWheelFactory

---

我怎样才能在温莎城堡做到这一点。即使意味着不使用子容器而不是子容器，请尝试标准服务覆盖：

var container = new WindsorContainer();

container.Register(Component.For<HostForThread1>().DependsOn(Property.ForKey<CarFactory>().Is("CarFactory1")));
container.Register(Component.For<HostForThread2>().DependsOn(Property.ForKey<CarFactory>().Is("CarFactory2")));

container.Register(Component.For<CarFactory>().DependsOn(Property.ForKey<WheelFactory>().Is<BigWheelFactory>()).Named("CarFactory1"));
container.Register(Component.For<CarFactory>().DependsOn(Property.ForKey<WheelFactory>().Is<SmallWheelFactory>()).Named("CarFactory2"));

container.Register(Component.For<WheelFactory>().ImplementedBy<BigWheelFactory>());
container.Register(Component.For<WheelFactory>().ImplementedBy<SmallWheelFactory>());


public class HostForThread1
{
    public HostForThread1(CarFactory factory)
    {
        this.Factory = factory;
    }

    public CarFactory Factory { get; }
}

public class HostForThread2
{
    public HostForThread2(CarFactory factory)
    {
        this.Factory = factory;
    }

    public CarFactory Factory { get; }
}

public class CarFactory
{
    public CarFactory(WheelFactory wheelFactory)
    {
        this.WheelFactory = wheelFactory;
    }

    public WheelFactory WheelFactory { get; }
}

public abstract class WheelFactory
{
}

public class BigWheelFactory : WheelFactory
{
}

public class SmallWheelFactory : WheelFactory
{
}

var容器=新的WindsorContainer（）；
container.Register（Component.For（）.DependsOn（Property.ForKey（）.Is（“CarFactory1”））；
container.Register（Component.For（）.DependsOn（Property.ForKey（）.Is（“CarFactory2”））；
container.Register（Component.For（）.DependsOn（Property.ForKey（）.Is（））.Named（“CarFactory1”）；
container.Register（Component.For（）.DependsOn（Property.ForKey（）.Is（））.Named（“CarFactory2”）；
container.Register（Component.For（）.ImplementedBy（））；
container.Register（Component.For（）.ImplementedBy（））；
公共类HostForThread1
{
public HostForThread1（汽车工厂）
{
这个。工厂=工厂；
}
公共汽车工厂{get；}
}
公共类HostForThread2
{
public HostForThread2（汽车工厂）
{
这个。工厂=工厂；
}
公共汽车工厂{get；}
}
公营汽车制造厂
{
公共汽车厂（车轮厂车轮厂）
{
this.WheelFactory=WheelFactory；
}
公共车轮工厂车轮工厂{get；}
}
公共抽象类工厂
{
}
公共级BigWheelFactory：WheelFactory
{
}
公共级SmallWheelFactory：WheelFactory
{
}

如果您指的是“流程”，则每个流程都应该有自己的DI配置，完全独立于其他流程。虽然可以序列化对象以将它们从一个进程发送到另一个进程，但这是应用程序的运行时设计特性，而不是与DI相关的特性，DI仅用于编写应用程序。“如果这不是你所说的过程，我建议你改变你的问题，以澄清你的实际意思。”夜猫子888建议得到认可。谢谢Hanks Jan，为了简单起见，我提到了线程1和线程2，但这可能是N个线程，我想这不会扩展。我的确切用例是针对ServiceFabric参与者的，我希望拥有所有通用注册和一些每个参与者的注册。这是因为在ServiceFabric中，我找不到任何方法来获取当前执行参与者的引用（就像HttpContext.current一样）。基本上，我需要每个参与者作用域的一些依赖项，并且我只能在每个参与者都有一个容器和一个用于公共内容的父容器的情况下才能做到这一点。@Gurpret也许这对您来说会很有趣：。无论如何，不建议将子容器与Castle一起使用，并且此特定示例对它们不起作用。所以您必须找到另一种解决方案，要么服务覆盖，要么实现自己的HandlersSelector，甚至可能是其他解决方案。