自定义 Autofac 的组件解析/通用协方差/逆变问题

Question

首先，对模糊的问题标题表示歉意。我无法想出一个更精确的答案。

给定这些类型：

                                                     { TCommand : ICommand }
       «interface»                   «interface»    /
      +-----------+         +----------------------/----+
      | ICommand  |         | ICommandHandler<TCommand> |
      +-----------+         +---------------------------+
            ^               | Handle(command: TCommand) |
            |               +---------------------------+
            |                              ^
            |                              |
      +------------+            +-------------------+
      | FooCommand |            | FooCommandHandler |
      +------------+            +-------------------+
            ^
            |
   +-------------------+
   | SpecialFooCommand |
   +-------------------+

我想编写一个方法Dispatch，它接受任何命令并将其发送到适当的ICommandHandler<>。我认为使用 DI 容器 (Autofac) 可能会大大简化从命令类型到命令处理程序的映射：

void Dispatch<TCommand>(TCommand command) where TCommand : ICommand
{
    var handler = autofacContainer.Resolve<ICommandHandler<TCommand>>();
    handler.Handle(command);
}

假设 DI 容器了解上面显示的所有类型。现在我正在调用：

Dispatch(new SpecialFooCommand(…));

实际上，这将导致 Autofac 抛出 ComponentNotRegisteredException，因为没有可用的 ICommandHandler。

然而，理想情况下，我仍然希望由最接近匹配的可用命令处理程序来处理 SpecialFooCommand ，即。通过上面示例中的 FooCommandHandler 。

Autofac 是否可以为此目的进行定制，也许可以使用定制注册源？

---

PS：我知道可能存在共变/逆变的根本问题（如下例所示），并且唯一的解决方案可能是不使用泛型的解决方案所有...但如果可能的话，我想坚持使用泛型类型。

ICommandHandler<FooCommand> fooHandler = new FooCommandHandler(…);
ICommandHandler<ICommand> handler = fooHandler;
//                                ^
//              doesn't work, types are incompatible

Answer 1

这并不是一个公平的答案，因为自从您发布问题以来我已经扩展了 Autofac...:)

根据 Daniel 的回答，您需要添加 in 修饰符到 ICommandHandler 的 TCommand 参数：

interface ICommandHandler<in TCommand>
{
    void Handle(TCommand command);
}

Autofac 2.5.2 现在包含一个 IRegistrationSource 来启用逆变 Resolve() 操作:

using Autofac.Features.Variance;

var builder = new ContainerBuilder();
builder.RegisterSource(new ContravariantRegistrationSource());

有了这个来源注册后，将查找由具有单个 in 参数的通用接口表示的服务，同时考虑变体实现：

builder.RegisterType<FooCommandHandler>()
   .As<ICommandHandler<FooCommand>>();

var container = builder.Build();
container.Resolve<ICommandHandler<FooCommand>>();
container.Resolve<ICommandHandler<SpecialFooCommand>>();

对 Resolve() 的两次调用都将成功检索 FooCommandHandler。

如果您无法升级到最新的 Autofac 软件包，请从 http://code.google.com/p/autofac/source/browse/src/Source/Autofac/Features/Variance/ContravariantRegistrationSource.cs - 它应该针对任何最新的 Autofac 版本进行编译。

Answer 2

如果没有自己的编码，您所问的问题是不可能的。
基本上，您要问以下问题：如果找不到我尝试解析的类型，请返回可以转换为该类型的另一种类型，例如，如果您尝试解析 IEnumerable 返回已注册的类型对于ICollection。
不支持此操作。
一种简单的解决方案如下：
将 FooCommandHandler 注册为 ICommandHandler 的处理程序。为此，ICommandHandler 需要逆变：

interface ICommand { }

class FooCommand : ICommand { }

class SpecialFooCommand : FooCommand { }

interface ICommandHandler<in T> where T : ICommand
{
    void Handle(T command);
}

class FooCommandHandler : ICommandHandler<FooCommand>
{
    public void Handle(FooCommand command)
    {
        // ...
    }
}

var builder = new ContainerBuilder();
builder.RegisterType<FooCommandHandler>()
       .As<ICommandHandler<SpecialFooCommand>>()
       .As<ICommandHandler<FooCommand>>();
var container = builder.Build();
var fooCommand = new FooCommand();
var specialCommand = new SpecialFooCommand();
container.Resolve<ICommandHandler<FooCommand>>().Handle(fooCommand);
container.Resolve<ICommandHandler<FooCommand>>().Handle(specialCommand);
container.Resolve<ICommandHandler<SpecialFooCommand>>().Handle(specialCommand);

顺便说一句：您使用容器的方式，您应用 服务定位器反模式。应该避免这种情况。

Answer 3

我喜欢添加一种替代方法，该方法在没有 C# 4.0 差异支持的情况下也可以工作。

您可以创建一个特殊的装饰器/包装器，允许将命令作为其基本类型执行：

public class VarianceHandler<TSubCommand, TBaseCommand> 
    : ICommandHandler<TSubCommand>
    where TSubCommand : TBaseCommand
{
    private readonly ICommandHandler<TBaseCommand> handler;

    public VarianceHandler(ICommandHandler<TBaseCommand> handler)
    {
        this.handler = handler;
    }

    public void Handle(TSubCommand command)
    {
        this.handler.Handle(command);
    }
}

有了这个，以下代码行将允许您将 SpecialFooCommand 作为其基本类型进行处理：

builder.Register<FooCommandHandler>()
    .As<ICommandHandler<FooCommand>>();

builder.Register<VarianceHandler<SpecialFooCommand, FooCommand>>()
    .As<ICommandHandler<SpecialFooCommand>>();

请注意，使用此类 VarianceHandler 适用于大多数 DI 容器。