我被 this SO question 触发了关于 Autofac 的 (.NET 4.0) 协变和逆变支持，现在我正在尝试实现类似的东西，但没有任何运气。

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

换句话说，当我这样写的时候:

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

handler.Handle(new CustomerMovedEvent());

关于应用程序设计(如下所示)，我期望 MultipleDispatchEventHandler<CustomerMovedEvent>返回的同时包含 CustomerMovedEventHandler和一个 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<TEvent> 的定义，在组合根中定义:

// 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();

使用当前配置，应用程序在调用 Resolve 期间失败, 但有以下异常(exception):

Autofac.Core.DependencyResolutionException: Circular component dependency detected: MultipleDispatchEventHandler'1[[SpecialCustomerMovedEvent]] -> IEventHandler'1[[SpecialCustomerMovedEvent]][] -> MultipleDispatchEventHandler'1[[SpecialCustomerMovedEvent]].

现在的问题当然是:我如何修复配置(或设计)以支持它？

最佳答案

我打算将其作为一个单独的答案，而不是修改我的另一个答案。此解决方案不使用复合 Material 来解决示例场景。

工作代码

我添加了一个 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<TEvent>而不是复合 IEventHandler<TEvent> .这是它的样子:

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肯定会使我们在组合根部的工作更容易。我们不必担心递归组合或确保组合是默认实现。但是我们添加了一个新接口(interface)IEventRaiser这可能看起来多余。是吗？我认为不是。

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

想象一下，我是一段想要引发事件的代码。如果我向 IoC 索要一个 IEventHandler我正在介绍我不需要的耦合。我不需要知道那个IEventHandler界面。我不应该要求任何人 Handle我的事件。我只想做 Raise它。处理可能会或可能不会发生在另一边；这与我无关。我很自私 - 我想要一个专为我和我引发事件的需要而创建的界面。

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

Interface Segregation Principle似乎更多是关于将胖接口(interface)拆分为更薄的接口(interface)(另请参见 Role Interface )。在我们的例子中，我们没有胖接口(interface)，但我认为我们正在做类似的事情——“按意图进行接口(interface)隔离”。

还有一件事

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

“Type C 接口(interface)”——经常使用，很少实现。一个“服务”接口(interface)。例如，IEventRaiser或 ICustomerRepository .这些接口(interface)可能只有一个实现(可能经过了一些修饰)，但它们被想要引发事件或挽救客户的代码在各处使用。

“I 类接口(interface)”- 经常实现，很少使用。一个“插件”界面。例如，IEventHandler<TEvent> .仅在一个地方使用(EventRaiser)但由许多类实现。

同一个接口(interface)不应该既是Type C又是Type I。这是分开IEventRaiser的另一个原因。 (C 型)来自 IEventHandler (类型 I)。

我认为复合模式只适用于Type C接口(interface)。

如果有我所谓的“C 类”和“I 类”接口(interface)的标准术语，请编辑或评论。

关于c# - Autofac:在一个组合后面隐藏多个逆变实现，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7139054/