是否可以对泛型类型使用构造函数注入？

Question

我的事件处理程序目前有 class 和这样的方法签名：

public class MyEventHandler : IIntegrationEventHandler

public void Handle(IntegrationEventintegrationEvent) // IntegrationEvent is the base class

我想做的是这个（以便处理程序可以接受具体类型）：

public class MyEventHandler : IIntegrationEventHandler<MyEvent>

public void Handle(MyEvent integrationEvent)

在Startup.cs中，我这样做了：

services.AddTransient<IIntegrationEventHandler<MyEvent>, MyEventHandler>();

问题是注入这些处理程序的服务不能使用开放泛型，如下所示：

public MyService(IEnumerable<IIntegrationEventHandler<>> eventHandlers)
            : base(eventHandlers)

指定基数 class 也不起作用：

public MyService(IEnumerable<IIntegrationEventHandler<IntegrationEvent>> eventHandlers)
            : base(eventHandlers)

这给了我 0 个处理程序。

当前方法的工作原理是我注入了所有 7 个处理程序。但这意味着处理程序必须在其方法中接受基 class 然后转换它。没什么大不了的，但如果我能让处理程序接受它关心的具体类型，那就太好了。这可能吗？

Answer 1

您的要求无法直接完成。 C# 集合始终绑定到特定的项目类型，如果需要不同的类型，则必须强制转换该类型。而IIntegrationEventHandler<MyEvent>和IIntegrationEventHandler<DifferentEvent>是不同的类型。

作为替代解决方案，您可以通过中介（调度程序）调度事件并使用反射和 DI 将它们路由到具体的处理程序类型。处理程序将使用它们声明要处理的特定事件类型向 DI 注册。您还可以使用单个处理程序实现来处理多种类型的事件。调度程序将根据运行时间类型直接从 IServiceProvider.

接收到的事件注入一组具体事件处理程序

我没有编译或测试下面的代码，但它应该给你大概的想法。

Startup.cs

services
    .AddTransient<IIntegrationEventHandler<MyEvent>, MyEventHandler>()
    .AddTransient<IntegrationEventDispatcher>();

IntegrationEventDispatcher.cs

private readonly IServiceProvider _serviceProvider;

public IntegrationEventDispatcher(IServiceProvider serviceProvider)
{
    _serviceProvider = serviceProvider;
}

public void Dispatch(IntegrationEvent @event)
{
    var eventType = @event.GetType();

    // TODO: Possibly cache the below reflected types for improved performance
    var handlerType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);
    var handlerCollectionType = typeof(IEnumerable<>).MakeGenericType(handlerType);
    var handlers = (IEnumerable)_serviceProvider.GetService(handlerCollectionType);

    var handleMethod = handlerType.GetMethod("Handle", eventType);

    foreach (var handler in handlers)
    {
        handleMethod.Invoke(handler, new[] { @event });
    }
}

MyService.cs

// ...

private readonly IntegrationEventDispatcher  _eventDispatcher;

public MyService(IntegrationEventDispatcher eventDispatcher)
{
    _eventDispatcher = eventDispatcher;
}

public void DoStuffAndDispatchEvents()
{
    // ...
    _eventDispatcher.Dispatch(new MyEvent());
    _eventDispatcher.Dispatch(new DifferentEvent());
}

编辑：

基于泛型的调度程序实现（gist）：

public void Dispatch<TEvent>(TEvent @event) where TEvent : IntegrationEvent 
{
    var handlers = _serviceProvider.GetRequiredService<IEnumerable<IIntegrationEventHandler<TEvent>>>();

    foreach (var handler in handlers)
    {
        handler.Handle(@event);
    }
}

编辑 2：为了支持基类型的事件处理，我想到了几种方法：

a) 使用上面的基于反射的方法。

就性能而言，这不是最好的，但它适用于它将接收的任何类型。

b) 使用类型开关

打开事件类型以使用正确的类型调用 Dispatch<T>。缺点是您需要列出所有支持的事件类型，并在引入任何新事件类型时更新列表。此外，这在测试中可能有些棘手。

IntegrationEventDispatcher逻辑变为

    public void Dispatch(IntegrationEvent @event)
    {
        switch (@event)
        {
            case MyIntegrationEvent e:
                Dispatch(e); // Calls Dispatch<TEvent> as the overload with a more specific type
                break;

            case OtherIntegrationEvent e:
                Dispatch(e);
                break;

            default:
                throw new NotSupportedException($"Event type {@event.GetType().FullName} not supported.");
        }
    }

    private void Dispatch<TEvent>(TEvent @event) where TEvent : IntegrationEvent
    {
        var handlers = _serviceProvider.GetRequiredService<IEnumerable<IEventHandler<TEvent>>>();

        foreach (var handler in handlers)
        {
            handler.Handle(@event);
        }
    }

具有最小实现的 Gist 可用 here。

c) 使用访客模式

使基本事件类型接受访问具体事件类型的访问者。这是相当多的代码，需要更改基本事件类型。添加新的事件类型时，会自动支持它，但如果使用重载而不是通用方法（如在适当的访问者中），则可能需要新的重载。

A IIntegrationEventVisitor 应该存在于与 IntegrationEvent 相同的级别 - 这可能是一个体系结构问题，但是，由于事件已经被设计为对象，我希望行为不应该是个问题，尤其是这个摘要。

IntegrationEvent.cs

public abstract class IntegrationEvent
{
    public abstract void Accept(IIntegrationEventVisitor visitor);
}

我的IntegrationEvent.cs

public class MyIntegrationEvent : IntegrationEvent
{
    public override void Accept(IIntegrationEventVisitor visitor)
    {
        visitor.Visit(this); // "this" is the concrete type so TEvent is inferred properly
    }
}

IIntegrationEventVisitor.cs

public interface IIntegrationEventVisitor
{
    // Note: This is not a proper visitor, feel free to implement 
    // overloads for individual concrete event types for proper design.
    // Generic method is not very useful for a visitor in general
    // so this is actually an abstraction leak.
    void Visit<TEvent>(TEvent @event) where TEvent : IntegrationEvent;
}

IntegrationEventDispatcher.cs

public class IntegrationEventDispatcher : IIntegrationEventVisitor
{
    // Previously known as Dispatch
    public void Visit<TEvent>(TEvent @event) where TEvent : IntegrationEvent
    {
        var handlers = _serviceProvider.GetRequiredService<IEnumerable<IEventHandler<TEvent>>>();

        foreach (var handler in handlers)
        {
            handler.Handle(@event);
        }
    }
}

具有最小实现的 Gist 可用 here。

d) 退一步

如果你想分派一个基类型，也许注入具体的处理程序根本不是你需要的，可能还有另一种方法。

我们创建一个采用基类型并仅在相关时处理它的事件处理程序怎么样？但是我们不要在每个处理程序中重复这些相关性检查，让我们做一个 class 来为我们做一般的事情并委托给适当的处理程序。

我们将使用 IIntegrationEventHandler 作为通用处理程序来接受基类型，使用通用类型实现它，检查接受的类型是否相关，然后将其转发给实现 IIntegrationEventHandler<TEvent>.

这种方法可以让您按照最初的要求在任何地方使用构造函数注入，并且通常感觉最接近您的原始方法。缺点是即使不使用所有处理程序也会实例化。这可以通过例如避免Lazy<T> 在具体处理程序集合上。

请注意，没有通用的 Dispatch 方法或其任何变体，您只需注入一个 IIntegrationEventHandler 的集合，其中每个委托到 IIntegrationEventHandler<TEvent> 的集合，如果接收到的事件类型是 TEvent.

IIntegrationEventHandler.cs

public interface IIntegrationEventHandler
{
    void Handle(IntegrationEvent @event);
}

public interface IIntegrationEventHandler<TEvent> where TEvent : IntegrationEvent
{
    void Handle(TEvent @event);
}

DelegatingIntegrationEventHandler.cs

public class DelegatingIntegrationEventHandler<TEvent> : IIntegrationEventHandler where TEvent : IntegrationEvent
{
    private readonly IEnumerable<IEventHandler<TEvent>> _handlers;

    public DelegatingIntegrationEventHandler(IEnumerable<IEventHandler<TEvent>> handlers)
    {
        _handlers = handlers;
    }

    public void Handle(IntegrationEvent @event)
    {
        // Check if this event should be handled by this type
        if (!(@event is TEvent concreteEvent))
        {
            return;
        }

        // Forward the event to concrete handlers
        foreach (var handler in _handlers)
        {
            handler.Handle(concreteEvent);
        }
    }
}

MyIntegrationEventHandler.cs

public class MyIntegrationEventHandler : IIntegrationEventHandler<MyIntegrationEvent>
{
    public void Handle(MyIntegrationEvent @event)
    {
        // ...
    }
}

具有最小实现的 Gist 可用 here。检查它的实际设置和使用情况，因为正确设置稍微复杂一些。

是否可以对泛型类型使用构造函数注入？

Is it possible to use constructor injection with a generic type?

c#

generics

dependency-injection

autofac