Castle windsor 城堡定制生活方式每决心

对于温莎城堡，假设我有以下课程：

public class LowLevelComponent
{
}

public class HighLevelComponent
{
    readonly LowLevelComponent LowLevelComponent;

    public HighLevelComponent(LowLevelComponent lowLevelComponent)
    {
        LowLevelComponent = lowLevelComponent;
    }
}

public class ComponentBeingResolved
{
    readonly LowLevelComponent LowLevelComponent;
    readonly HighLevelComponent HighLevelComponent;

    public ComponentBeingResolved(LowLevelComponent lowLevelComponent,
                                  HighLevelComponent highLevelComponent)
    {
        LowLevelComponent = lowLevelComponent;
        HighLevelComponent = highLevelComponent;
    }
}

以最简单的方式注册：

container.Register(Component.For<LowLevelComponent>());
container.Register(Component.For<HighLevelComponent>());
container.Register(Component.For<ComponentBeingResolved>());

以下断言应为真：

instance1.LowLevelComponent == instance1.HighLevelComponent.LowLevelComponent
instance1.LowLevelComponent != instance2.LowLevelComponent
instance1.HighLevelComponent != instance2.HighLevelComponent

---

我还想用“你做的每件事都是错的，这是你应该做的”作为答案：-）

你一定听说过有人建议你的应用程序入口点（Main、Controller等）只调用一次Resolve。Castle文档在这方面做得很好。

您一定听过有人建议只为您的应用程序入口点（Main、Controller等）调用Resolve一次。Castle文档在这方面做得很好。

基于Mauricio的链接，我使用工厂实现了它：

public interface IComponentFactory
{
    T Get<T>();
}

var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.Register(Component.For<LowLevelComponent>()
         .LifeStyle.Custom<ContextualLifestyle>());
container.Register(Component.For<HighLevelComponent>()
         .LifeStyle.Custom<ContextualLifestyle>());
container.Register(Component.For<IComponentFactory>().AsFactory());
//Register the "context-root" component in a child container
var subContainer = new WindsorContainer();
subContainer.Register(Component.For<ComponentBeingResolved>()
            .LifeStyle.Transient);
container.AddChildContainer(subContainer);
container.Register(
    Component.For<ComponentBeingResolved>()
        .LifeStyle.Transient
        //Here's the magic
        .UsingFactoryMethod(
            () =>
                {
                    using (new ContainerContext(container))
                        return subContainer.Resolve<ComponentBeingResolved>();
                }));

公共接口IComponentFactory
{
T Get（）；
}
var container=新的WindsorContainer（）；
container.AddFacility（）；
container.Register（Component.For（））
.生活方式.习俗（））；
container.Register（Component.For（））
.生活方式.习俗（））；
container.Register（Component.For（）.AsFactory（））；
//在子容器中注册“上下文根”组件
var subcainer=新的WindsorContainer（）；
subcainer.Register（Component.For（））
(生活方式,短暂),；
container.AddChildContainer（分包商）；
集装箱。登记(
用于（）的组件
.短暂的
//这就是魔法
.使用工厂法(
() =>
{
使用（新容器上下文（容器））
返回subcainer.Resolve（）；
}));

用法：

var factory = container.Resolve<IComponentFactory>();
var instance1 = factory.Get<ComponentBeingResolved>();
var instance2 = factory.Get<ComponentBeingResolved>();

var factory=container.Resolve（）；
var instance1=factory.Get（）；
var instance2=factory.Get（）；

---

不确定这是一个好的黑客还是一个丑陋的黑客，但它工作得非常好。

根据Mauricio的链接，我使用工厂实现了它：

public interface IComponentFactory
{
    T Get<T>();
}

var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.Register(Component.For<LowLevelComponent>()
         .LifeStyle.Custom<ContextualLifestyle>());
container.Register(Component.For<HighLevelComponent>()
         .LifeStyle.Custom<ContextualLifestyle>());
container.Register(Component.For<IComponentFactory>().AsFactory());
//Register the "context-root" component in a child container
var subContainer = new WindsorContainer();
subContainer.Register(Component.For<ComponentBeingResolved>()
            .LifeStyle.Transient);
container.AddChildContainer(subContainer);
container.Register(
    Component.For<ComponentBeingResolved>()
        .LifeStyle.Transient
        //Here's the magic
        .UsingFactoryMethod(
            () =>
                {
                    using (new ContainerContext(container))
                        return subContainer.Resolve<ComponentBeingResolved>();
                }));

公共接口IComponentFactory
{
T Get（）；
}
var container=新的WindsorContainer（）；
container.AddFacility（）；
container.Register（Component.For（））
.生活方式.习俗（））；
container.Register（Component.For（））
.生活方式.习俗（））；
container.Register（Component.For（）.AsFactory（））；
//在子容器中注册“上下文根”组件
var subcainer=新的WindsorContainer（）；
subcainer.Register（Component.For（））
(生活方式,短暂),；
container.AddChildContainer（分包商）；
集装箱。登记(
用于（）的组件
.短暂的
//这就是魔法
.使用工厂法(
() =>
{
使用（新容器上下文（容器））
返回subcainer.Resolve（）；
}));

用法：

var factory = container.Resolve<IComponentFactory>();
var instance1 = factory.Get<ComponentBeingResolved>();
var instance2 = factory.Get<ComponentBeingResolved>();

var factory=container.Resolve（）；
var instance1=factory.Get（）；
var instance2=factory.Get（）；

---

不确定这是一个好的黑客还是一个丑陋的黑客，但它工作得非常好。

是的，我读过那篇文章，我想我可以使用类型化工厂来获取正在解决的

组件，但这并不能解决问题，是吗？是的，我读过那篇文章，我想我可以使用类型化工厂来获得正在解决的组件，但这并不能解决问题，不是吗？可能重复同样的问题，看看German的上下文生活方式：@MauricioScheffer:看起来正是我需要的！但是有没有办法避免手动创建作用域？例如，如果我使用类型化的工厂设施……可能与该问题相同的问题重复，请查看German的上下文生活方式：@MauricioScheffer:看起来正是我需要的！但是有没有办法避免手动创建作用域？例如，如果我使用类型化工厂设施…是否需要子容器？@MauricioScheffer：如果我直接在内核/容器上调用Resolve，这是避免堆栈溢出的方法。是否需要子容器？@MauricioScheffer：如果我直接在内核/容器上调用Resolve，这是避免堆栈溢出的方法