1

我正在一一注册几种类型：

container.Register(
     Component.For<IService1>().ImplementedBy<ServiceImpl1>(),
     Component.For<IService2>().ImplementedBy<ServiceImpl2>(),
     Component.For<IService3>().ImplementedBy<ServiceImpl3>(),
     Component.For<IService4>().ImplementedBy<ServiceImpl4>()
     );

有没有办法为已注册的所有类型的程序集注册一个拦截器？我不想按照惯例注册所有类型AllTypes。我只想添加一个拦截器而不写

.Interceptors(InterceptorReference.ForType<DummyInterceptor>())
            .SelectedWith(new FooInterceptorSelector()).Anywhere

无数次。

谢谢！

4

2 回答 2

0

使用 ComponentModel 贡献者时如何指定 .SelectedWith ？我可以通过这样做为所有方法添加一个拦截器。

public class MyContributor : IContributeComponentModelConstruction 
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        model.Dependencies.Add(new DependencyModel(DependencyType.Service, null, typeof(MyInterceptor), false));
        model.Interceptors.AddFirst(InterceptorReference.ForType<MyInterceptor>());
    }
}
于 2011-10-28T14:53:49.143 回答
0

正如Dan 所建议的，这可以使用自定义ComponentModel 构造贡献者来实现。

首先，请注意

...
    .Interceptors(InterceptorReference.ForType<DummyInterceptor>())
        .SelectedWith(new FooInterceptorSelector())
        .Anywhere

基本上相当于

...
    .SelectInterceptorsWith(new FooInterceptorSelector())
    .Interceptors(InterceptorReference.ForType<DummyInterceptor>())
        .Anywhere

也就是说，将IInterceptorSelectora 与 a关联ComponentModel独立于注册拦截器，这些拦截器将使用IInterceptorSelector. 此外，每个ComponentModel可能只有一个拦截器选择器。

由于这种分离，问题最好使用两个独立的贡献者来解决——一个用于注册拦截器，另一个用于注册拦截器选择器。

第一个与丹的答案中显示的基本相同。但是，不需要DependencyModel为拦截器添加一个，因为拦截器应该已经使用类似的东西注册到容器中

container.Register(Component.For<DummyInterceptor>().LifestyleTransient());

所以它看起来像

using Castle.Core;
using Castle.MicroKernel;
using Castle.MicroKernel.ModelBuilder;

...

public class InterceptorContributor : IContributeComponentModelConstruction
{
    private readonly InterceptorReference interceptor;

    public InterceptorContributor(InterceptorReference interceptor)
    {
        this.interceptor = interceptor;
    }

    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (...)
        {
            model.Interceptors.Add(interceptor)
        }
    }
}

或者如果您希望能够一次性注册多个拦截器，则可以利用现有的实现InterceptorDescriptor，而不是：

using System;

using Castle.Core;
using Castle.MicroKernel;
using Castle.MicroKernel.ModelBuilder;
using Castle.MicroKernel.ModelBuilder.Descriptors;

...

public class InterceptorsContributor : IContributeComponentModelConstruction
{
    private readonly Predicate<ComponentModel> predicate;
    private readonly IComponentModelDescriptor interceptorsDescriptor;

    public InterceptorsContributor(Predicate<ComponentModel> predicate, params InterceptorReference[] interceptors)
    {
        this.predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
        interceptorsDescriptor = new InterceptorDescriptor(interceptors);
    }

    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (predicate.Invoke(model))
        {
            interceptorsDescriptor.BuildComponentModel(kernel, model);
            interceptorsDescriptor.ConfigureComponentModel(kernel, model);
        }
    }
}

对于注册一个IInterceptorSelector，贡献者可以通过执行以下操作来实现InterceptorSelectorDescriptor：

public void ProcessModel(IKernel kernel, ComponentModel model)
{
    if (...)
    {
        var options = model.ObtainProxyOptions();
        options.Selector = new InstanceReference<IInterceptorSelector>(selector);
    }
}

或InterceptorSelectorDescriptor直接使用：

using System;

using Castle.Core;
using Castle.DynamicProxy;
using Castle.MicroKernel;
using Castle.MicroKernel.ModelBuilder;
using Castle.MicroKernel.ModelBuilder.Descriptors;

...

public class InterceptorSelectorContributor : IContributeComponentModelConstruction
{
    private readonly Predicate<ComponentModel> predicate;
    private readonly IComponentModelDescriptor interceptorSelectorDescriptor;

    public InterceptorSelectorContributor(Predicate<ComponentModel> predicate, IInterceptorSelector selector)
    {
        this.predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));

        var selectorRef = new InstanceReference<IInterceptorSelector>(selector);
        interceptorSelectorDescriptor = new InterceptorSelectorDescriptor(selectorRef);
    }

    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (predicate.Invoke(model))
        {
            interceptorSelectorDescriptor.BuildComponentModel(kernel, model);
            interceptorSelectorDescriptor.ConfigureComponentModel(kernel, model);
        }
    }
}
于 2018-05-29T17:00:52.067 回答