Proxy 温莎城堡组件激活剂的预期生活方式是什么？

我使用Castle Windsor和DynamicProxy从头开始实现持久性延迟加载（我知道NHibernate可能是一个选项等）。我已经实现了一个自定义组件激活器，以始终将我的业务类实例化为代理。我发现当从类本身内部调用类方法时，在使用拦截器时自动创建的默认mixin代理没有被使用，这是一个问题。因此，我继承了DefaultComponentActivator并重写了CreateInstance（），我调用CreateClassProxy（）来获取一个从业务类继承的代理，在这方面它工作得很好

现在我希望Castle只实例化我的这个“ProxyComponentActivator”激活器一次，但是正在为每个类类型创建一个新实例。对吗

目前的注册情况如下：

public void Install(
   IWindsorContainer container,
   Castle.MicroKernel.SubSystems.Configuration.IConfigurationStore store) {
    container.Register( 
        Classes
            .FromAssemblyContaining(typeof(OneOfMyBusinessClasses))
            .InNamespace(typeof(OneOfMyBusinessClasses).Namespace)
            .WithService.DefaultInterfaces()
            .Configure(reg => reg.Activator<ProxyComponentActivator>())
            .LifestyleTransient(),
        etc.
    );
);

public-void安装(
我喜欢集装箱，
Castle.MicroKernel.subsystem.Configuration.IConfigurationStore（存储）{
货柜登记册（
班级
.FromAssemblyContaining（typeof（混合业务类之一））
.InNamespace（typeof（OfMyBusinessClasses之一）.Namespace）
.WithService.DefaultInterfaces（）
.Configure（reg=>reg.Activator（））
.生活方式，
等
);
);

activator实现如下所示：

public class ProxyComponentActivator : DefaultComponentActivator
{
    protected Castle.DynamicProxy.ProxyGenerator ProxyGenerator { get; set; }
    protected PersistenceInterceptor PersistenceInterceptor { get; set; }


    public ProxyComponentActivator(ComponentModel model, Castle.MicroKernel.IKernelInternal kernel, ComponentInstanceDelegate onCreation, ComponentInstanceDelegate onDestruction)
        : base(model, kernel, onCreation, onDestruction)
    {
        this.ProxyGenerator = kernel.Resolve<Castle.DynamicProxy.ProxyGenerator>();
        this.PersistenceInterceptor = kernel.Resolve<PersistenceInterceptor>();
    }


    protected override object CreateInstance(CreationContext context, ConstructorCandidate constructor, object[] arguments) //, Type[] signature)
    {
        object instance;

        Type implType = this.Model.Implementation;

        ProxyGenerationOptions p = new ProxyGenerationOptions();

        IPersistent ip = new Persistent();
        p.AddMixinInstance(ip);

        try
        {          
            instance = this.ProxyGenerator.CreateClassProxy(implType, null, p, arguments, this.PersistenceInterceptor);                
        }
        catch
        {
            throw new ComponentActivatorException("ComponentActivator: could not proxy " + implType.FullName, Model);
        }

        return instance;
    }
}

公共类ProxyComponentActivator:DefaultComponentActivator
{
受保护的Castle.DynamicProxy.ProxyGenerator ProxyGenerator{get；set；}
受保护的PersistenceInterceptor PersistenceInterceptor{get；set；}
公共ProxyComponentActivator（ComponentModel、Castle.MicroKernel.IKernelInternal内核、ComponentInstanceDelegate onCreation、ComponentInstanceDelegate onDestruction）
：base（模型、内核、onCreation、onDestruction）
{
this.ProxyGenerator=kernel.Resolve（）；
this.PersistenceInterceptor=kernel.Resolve（）；
}
受保护的重写对象CreateInstance（CreationContext上下文、构造函数Candidate构造函数、对象[]参数）/，类型[]签名）
{
对象实例；
类型implType=this.Model.Implementation；
ProxyGenerationOptions p=新的ProxyGenerationOptions（）；
IPersistent ip=新的持久性（）；
p、 添加混合状态（ip）；
尝试
{          
instance=this.ProxyGenerator.CreateClassProxy（implType，null，p，arguments，this.PersistenceInterceptor）；
}
抓住
{
抛出新的ComponentActivatorException（“ComponentActivator:无法代理”+implType.FullName，Model）；
}
返回实例；
}
}

我也试着像这样注册激活器，但没有用

Component.For<ProxyComponentActivator>()
.ImplementedBy<ProxyComponentActivator>()
.LifestyleSingleton()

Component.For（）
.由（）实施
.生活方式单身（）

提前感谢您的帮助，

---

Luis

Windsor中的每个组件都会有自己的activator实例

好的，所以我没有做错。为什么它不能是一个单例呢？似乎它可以重复使用。谢谢。