城堡拦截器:如何将拦截器添加到所有已注册的类型

Question

我正在逐个注册几个类型:

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

无数次。

谢谢!

Answer 1

根据Dan的建议，这可以使用自定义ComponentModel构建贡献者来实现。

首先，注意

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

基本上等同于

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

即，将IInterceptorSelector与ComponentModel相关联与注册将使用IInterceptorSelector选择的拦截器无关。而且，每个ComponentModel只能有一个拦截器选择器。

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

第一个与Dan的答案基本相同。但是，不应该为拦截器添加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);
        }
    }
}

Answer 2

如何在使用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>());
    }
}