Autofac：将多个逆变实现隐藏在一个组合后面

Question

我被这个关于 (. NET 4.0）对 Autofac 的协变和逆变支持，现在我正在尝试实现类似的目标，但没有任何运气。

我想要实现的是以这样的方式配置 Autofac，当我解析单个具体的 IEventHandler 时（为了使用 container.Resolve 进行演示，但通常情况下当然使用构造函数注入），Autofac 将返回一个 MultipleDispatchEventHandler ，它包装了所有可从请求的处理程序分配的已注册事件处理程序。

换句话说，当我这样写时：

var handler = container
    .GetInstance<IEventHandler<CustomerMovedEvent>>();

handler.Handle(new CustomerMovedEvent());

关于应用程序设计（如下所示），我希望返回一个包含 CustomerMovedEventHandler 的 MultipleDispatchEventHandler > 和一个 NotifyStaffWhenCustomerMovedEventHandler。

这是应用程序设计：

// Events:
public class CustomerMovedEvent { }

public class CustomerMovedAbroadEvent : CustomerMovedEvent { }

public class SpecialCustomerMovedEvent : CustomerMovedEvent { }


// Event handler definition (note the 'in' keyword):
public interface IEventHandler<in TEvent> 
{
    void Handle(TEvent e);
}

// Event handler implementations:
public class CustomerMovedEventHandler
    : IEventHandler<CustomerMovedEvent>
{
    public void Handle(CustomerMovedEvent e) { ... }
}

public class NotifyStaffWhenCustomerMovedEventHandler
    : IEventHandler<CustomerMovedEvent>
{
    public void Handle(CustomerMovedEvent e) { ... }
}

public class CustomerMovedAbroadEventHandler
    : IEventHandler<CustomerMovedAbroadEvent>
{
    public void Handle(CustomerMovedAbroadEvent e) { ... }
}

这是在组合根中定义的 MultipleDispatchEventHandler 的定义：

// A composite wrapping possibly multiple handlers.
public class MultipleDispatchEventHandler<TEvent>
    : IEventHandler<TEvent>
{
    private IEnumerable<IEventHandler<TEvent>> handlers;

    public MultipleDispatchEventHandler(
        IEnumerable<IEventHandler<TEvent>> handlers)
    {
        this.handlers = handlers;
    }

    public void Handle(TEvent e)
    {
        this.handlers.ToList().ForEach(h => h.Handle(e));
    }
}

这是我当前的配置：

var builder = new ContainerBuilder();

// Note the use of the ContravariantRegistrationSource (which is 
// available in the latest release of Autofac).
builder.RegisterSource(new ContravariantRegistrationSource());

builder.RegisterAssemblyTypes(typeof(IEventHandler<>).Assembly) 
    .AsClosedTypesOf(typeof(IEventHandler<>));

// UPDATE: I'm registering this last as Kramer suggests.
builder.RegisterGeneric(typeof(MultipleDispatchEventHandler<>))
    .As(typeof(IEventHandler<>)).SingleInstance();

var container = builder.Build();

使用当前配置，应用程序在调用 解决，但有以下例外：

Autofac.Core.DependencyResolutionException：圆形组件 检测到依赖性： MultipleDispatchEventHandler'1[[SpecialCustomerMovedEvent]] -> IEventHandler'1[[SpecialCustomerMovedEvent]][] -> MultipleDispatchEventHandler'1[[SpecialCustomerMovedEvent]]。

现在的问题当然是：如何修复配置（或设计）来支持这一点？

Answer 1

我将把这个作为一个单独的答案，而不是修改我的另一个答案。这个解决方案不使用组合来解决示例场景。

工作代码

为了测试目的，我向每个事件处理程序添加了一个 static int handleCount ，如下所示：

public class CustomerMovedEventHandler
    : IEventHandler<CustomerMovedEvent>
{
    public static int handleCount = 0;
    public void Handle(CustomerMovedEvent e) { handleCount++; }
}

这是一个通过的测试，表明事件正在去往它们应该去的地方：

var builder = new ContainerBuilder();

builder.RegisterSource(new Autofac.Features
    .Variance.ContravariantRegistrationSource());

builder.RegisterAssemblyTypes(typeof(IEventHandler<>).Assembly)
    .AsClosedTypesOf(typeof(IEventHandler<>));

builder.RegisterGeneric(typeof(EventRaiser<>))
    .As(typeof(IEventRaiser<>));

var container = builder.Build();

Assert.AreEqual(0, CustomerMovedEventHandler.handleCount);
Assert.AreEqual(0, NotifyStaffWhenCustomerMovedEventHandler.handleCount);
Assert.AreEqual(0, CustomerMovedAbroadEventHandler.handleCount);

container.Resolve<IEventRaiser<CustomerMovedEvent>>()
    .Raise(new CustomerMovedEvent());

Assert.AreEqual(1, CustomerMovedEventHandler.handleCount);
Assert.AreEqual(1, NotifyStaffWhenCustomerMovedEventHandler.handleCount);
Assert.AreEqual(0, CustomerMovedAbroadEventHandler.handleCount);

container.Resolve<IEventRaiser<CustomerMovedAbroadEvent>>()
    .Raise(new CustomerMovedAbroadEvent());

Assert.AreEqual(2, CustomerMovedEventHandler.handleCount);
Assert.AreEqual(2, NotifyStaffWhenCustomerMovedEventHandler.handleCount);
Assert.AreEqual(1, CustomerMovedAbroadEventHandler.handleCount);

container.Resolve<IEventRaiser<SpecialCustomerMovedEvent>>()
    .Raise(new SpecialCustomerMovedEvent());

Assert.AreEqual(3, CustomerMovedEventHandler.handleCount);
Assert.AreEqual(3, NotifyStaffWhenCustomerMovedEventHandler.handleCount);
Assert.AreEqual(1, CustomerMovedAbroadEventHandler.handleCount);

您可以看到我正在使用IEventRaiser 而不是复合 IEventHandler。它看起来是这样的：

public interface IEventRaiser<TEvent>
{
    void Raise(TEvent e);
}

public class EventRaiser<TEvent> : IEventRaiser<TEvent>
{
    List<IEventHandler<TEvent>> handlers;

    public EventRaiser(IEnumerable<IEventHandler<TEvent>> handlers)
    {
        this.handlers = handlers.ToList();
    }

    public void Raise(TEvent e)
    {
        handlers.ForEach(h => h.Handle(e));
    }
}

设计思想

避免复合 IEventHandler 肯定会让我们在组合根上的工作变得更容易。我们不必担心递归组合或确保组合是默认实现。但我们添加了一个新的接口IEventRaiser，它可能看起来多余。是吗？我认为不是。

引发事件和处理事件是两件不同的事情。 IEventHandler 是一个与处理事件有关的接口。 IEventRaiser 是一个与引发事件有关的接口。

想象一下我是一段想要引发事件的代码。如果我向 IoC 请求单个 IEventHandler，我就会引入我不需要的耦合。我不需要了解该 IEventHandler 接口。我不应该要求任何人处理我的活动。我想做的就是提高它。处理可能会也可能不会发生在另一侧；这与我无关。我很自私 - 我想要一个专门为我创建的界面以及我引发事件的需要。

作为事件引发者，我打算引发一个事件。作为事件处理程序，我打算处理一个事件。我们有两个不同的意图，所以我们应该有两个不同的接口。仅仅因为我们可以使用相同的接口和组合并不意味着我们应该这样做。

接口隔离原则似乎更多的是关于将胖接口分割成更薄的接口（另请参阅角色接口）。在我们的例子中，我们没有胖接口，但我认为我们正在做类似的事情 - “按意图进行接口隔离”。

还有一件事

在写这个答案时，我几乎阐明了一个我认为我们很多人都熟悉的设计习惯，但我认为我们没有标准的术语。

“C 型接口”——经常使用，很少实现。 “服务”界面。例如，IEventRaiser 或 ICustomerRepository。这些接口可能只有一个实现（可能进行了一些修饰），但它们被想要引发事件或拯救客户的代码到处使用。

“I 类接口”——经常实现，很少使用。 “插件”界面。例如，IEventHandler。仅在一个地方（EventRaiser）使用，但由许多类实现。

同一接口不应同时是 Type C 和 Type I。这是将 IEventRaiser（Type C）与 IEventHandler（Type I）分开的另一个原因。

我认为复合模式仅适用于 Type C 接口。

如果我所说的“Type C”和“Type I”接口有标准术语，请编辑或评论。

Answer 2

@default.kramer 为 IEventRaiser +1。仅作为记录，因为链接的答案不提供任何代码，并且由于涉及泛型类型，此场景的配置有点不太直观：

builder.RegisterSource(new ContravariantRegistrationSource());

builder.RegisterAssemblyTypes(...)
    .As(t => t.GetInterfaces()
        .Where(i => i.IsClosedTypeOf(typeof(IEventHandler<>)))
        .Select(i => new KeyedService("handler", i)));

builder.RegisterGeneric(typeof(MultipleDispatchEventHandler<>))
    .As(typeof(IEventHandler<>))
    .WithParameter(
         (pi, c) => pi.Name == "handlers",
         (pi, c) => c.ResolveService(
             new KeyedService("handler", pi.ParameterType)));