注册DynamicProxy动态创建的城堡组件

Question

因此，我一直在努力构建一个解决方案，该解决方案只使用Castle DynamicProxy（版本2.2）和拦截器创建某些组件。一切看起来都很棒，除了在这一切的最后，我意识到我需要用windsor容器注册这些组件。这是可能的还是我的工作是没有用的？

我会编造2个城堡配置来解释我的问题。第一个工作，而第二个不工作。

首先配置（这已经工作了一段时间大）：

<castle> 
    <facilities> 
    <facility 
     id="factory.support" 
     type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" /> 
    </facilities> 

    <components> 
    <component 
     id="Factory" 
     service="Foo.IFactory, Foo" 
     type="Foo.Local.LocalFactory, Foo.Local" /> 
    <component 
     id="Loader" 
     service="Foo.Contracts.ILoader, Foo.Contracts" 
     type="Foo.Local.Loader, Foo.Local" 
     factoryId="Factory" factoryCreate="GetLoader" /> 
    </components> 
</castle> 

其次配置（我不知道该放什么类型的属性，它并没有它的工作）：

<castle> 
    <facilities> 
    <facility 
     id="factory.support" 
     type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" /> 
    </facilities> 

    <components> 
    <component 
     id="Factory" 
     service="Foo.IFactory, Foo" 
     type="Foo.Remote.RemoteFactory, Foo.Remote" /> 
    <component 
     id="Loader" 
     service="Foo.Contracts.ILoader, Foo.Contracts" 
     type="I DUNNO, WHAT'S THE TYPE?" 
     factoryId="Factory" factoryCreate="GetLoader" /> 
    </components> 
</castle> 

所以我制造的配置注册工厂设施，然后我注册一个工厂，然后注册我的“ILoader”组件。 “LocalFactory”为ILoader组件创建实际类型，而“RemoteFactory”使用动态代理创建ILoader组件，创建无目标的代理。即，我使用ProxyGenerator.CreateInterfaceProxyWithoutTarget方法，因此没有基础类。

那么，根据第二个配置注册组件有没有希望？

编辑： 不幸的是，使用流利的配置API目前不是一种选择。所以为了缩小我的问题，是否可以使用XML配置来实现这一点？

Answer 1

我相信这可以通过Fluent Registration API和“UsingFactoryMethod”机制来实现。我试图在下面的测试案例中复制你的制作场景。

UPDATE

这实际上可能与XML配置为好。诀窍就是将接口本身列为配置中的“类型”（或者等同于只指定“类型”，因为如果未明确提供，“服务”将被设置为“类型”）。我已经更新了下面的测试用例，以包含一个使用xml配置实现所需结果的“TestXml”测试。 “TestFluent”测试使用流畅的注册API来实现它。仅供参考，我在这里使用Castle Windsor 2.0，因为我猜这就是你正在使用的。

using Castle.DynamicProxy; 
using Castle.Facilities.FactorySupport; 
using Castle.MicroKernel.Registration; 
using Castle.Windsor; 
using NUnit.Framework; 

namespace CastleTests 
{ 
    public interface ILoader 
    { 
     void Load(); 
    } 

    public interface ILoaderFactory 
    { 
     ILoader GetLoader(); 
    } 

    public class LoaderFactory : ILoaderFactory 
    { 
     public ILoader GetLoader() 
     { 
      return GetLoaderStatic(); 
     } 

     public static ILoader GetLoaderStatic() 
     { 
      return (ILoader) new ProxyGenerator().CreateInterfaceProxyWithoutTarget(typeof (ILoader)); 
     } 
    } 

    [TestFixture] 
    public class DynamicFactoryTests 
    { 
     [Test] 
     public void TestFluent() 
     { 
      using (var container = new WindsorContainer()) 
      { 
       container.AddFacility<FactorySupportFacility>(); 
       container.Register(
        Component.For<ILoader>().UsingFactoryMethod(() => LoaderFactory.GetLoaderStatic()) 
        ); 
       var loader = container.Resolve<ILoader>(); 
       Assert.That(loader.GetType().FullName, Is.EqualTo("Castle.Proxies.ILoaderProxy")); 
      } 
     } 

     [Test] 
     public void TestXml() 
     { 
      using (var container = new WindsorContainer("factory.xml")) 
      { 
       var loader = container.Resolve<ILoader>(); 
       Assert.That(loader.GetType().FullName, Is.EqualTo("Castle.Proxies.ILoaderProxy")); 
      } 
     } 
    } 
} 

“factory.xml”的内容正是如此：

<castle> 
    <facilities> 
    <facility 
     id="factory.support" 
     type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" /> 
    </facilities> 
    <components> 
    <component 
     id="foo" 
     service="CastleTests.ILoaderFactory, CastleTests" 
     type="CastleTests.LoaderFactory, CastleTests" /> 
    <component 
     id="bar" 
     type="CastleTests.ILoader, CastleTests" 
     factoryId="foo" factoryCreate="GetLoader" /> 
    </components> 
</castle>