Simple Injector 3不返回一般实例

Question

I am using Simple Injector and just updated from v2 to v3. I am using the DI container to resolve associated event handlers to an event.

All EventHandlers implement the interface IDomainEventHandler and all events implement IDomainEvent .

The EventHandlers are registered:

container.Register(typeof(IDomainEventHandler<>),
    new[] { typeof(IDomainEventHandler).Assembly });

I collect all handlers to a certain event like so:

public void Dispatch<TDomainEvent>(TDomainEvent domainEvent) 
    where TDomainEvent : IDomainEvent
{
    var eventHandlers =
        _dependencyResolver.GetAllInstances<IDomainEventHandler<TDomainEvent>>();

    foreach (var domainEventHandler in eventHandlers)
        domainEventHandler.Handle(domainEvent); 
}

I have a general event handler, which handles all events who implements IDomainEvent interface. It is defined like this:

public class EventStoreDomainEventHandler : IDomainEventHandler<IDomainEvent>
{
    public void Handle(IDomainEvent domainEvent)
    { ... }
}

When I try to get all instances from the DI container of a certain event which implements the IDomainEvent interface, I don't receive an instance of the EventStoreDomainEventhandler .

Is there a way to register and get all handlers of a type, and also all handlers associated to interfaces implemented by the type?

Hope it makes sense :o)

Kind Regards Frederik

Answer 1

This happens because Simple Injector separates registration of collections from one-to-one mappings , while you are registering your handlers with Register , while you are resolving them with GetAllInstances . You should either use the following combination:

container.Register(typeof(IDomainEventHandler<>), assemblies);

_dependencyResolver.GetInstance<IDomainEventHandler<TDomainEvent>>();

or:

// NOTE: v4.3+ syntax
container.Collection.Register(typeof(IDomainEventHandler<>), assemblies);

_dependencyResolver.GetAllInstances<IDomainEventHandler<TDomainEvent>>();

Answer 2

You need to explicitly state the variance in within your interface definition

public interface IDomainEventHandler<in TDomainEvent> { }

marking the interface with in and out keywords communicates that covariance and contravariance is expected and there could therefore be multiple applicable implementations

See here for full details.