autofac Risolvi tutti i tipi di tipo generico aperto?

Question

Immagino che non ci sia modo di fare qualcosa di simile a quanto segue con Autofac, in modo da iniettare una serie enumerabile di tipi generici aperti? I vari tipi di handle hanno dipendenze, altrimenti li svilupperei solo dinamicamente.

class EventOne : IEvent {...} 
    class EventTwo : IEvent {...} 
    class EventThree : IEvent {...} 
    interface IHandleEvent<T> where T : IEvent {...} 
    class HandleEventOne : IHandleEvent<EventOne> {...} 
    class HandleEventTwo : IHandleEvent<EventTwo> {...} 
    class HandleEventThree : IHandleEvent<EventThree> {...} 

    builder.RegisterAssemblyTypes(myAssembies).AsClosedTypesOf(typeof(IHandleEvent<>)); 
    builder.RegisterType<AService>().As<IAService>(); 


    class AService : IAService 
    { 
     public AService(IEnumerable<IHandleEvent<IEvent>> handles) 
     {...} 
    } 

Answer 1

Come spiegato nei commenti, ciò che si vuole è impossibile da raggiungere in C# e con buona ragione. Se si fosse in grado di trasmettere un valore IHandleEvent<EventOne> a un IHandleEvent<IEvent>, sarebbe consentito inoltrare anche uno EventTwo, il che non riuscirebbe in fase di esecuzione.

Quindi, ciò di cui hai bisogno è un'astrazione del mediatore che consenta di chiamare tutti i gestori di eventi compatibili. Tale mediatore è spesso chiamato IEventPublisher e potrebbe essere simile a questo:

public interface IEventPublisher { 
    void Publish(IEvent e); 
} 

è ora possibile creare una specifica implementazione contenitore. Per esempio, per Autofac questo apparirebbe come segue:

public class AutofacEventPublisher : IEventPublisher { 
    private readonly IComponentContext container; 

    public AutofacBusinessRuleValidator(IComponentContext container) { 
     this.container = container; 
    } 

    public void Publish(IEvent e) { 
     foreach (dynamic handler in this.GetHandlers(e.GetType())) { 
      handler.Handle((dynamic)e); 
     } 
    } 

    private IEnumerable GetHandlers(Type eventType) => 
     (IEnumerable)this.container.Resolve(
      typeof(IEnumerable<>).MakeGenericType(
       typeof(IHandleEvent<>).MakeGenericType(eventType))); 
} 

I consumatori possono ora dipendere da questa nuova astrazione:

class AService : IAService 
{ 
    public AService(IEventPublisher publisher) {...} 
} 

Answer 2

Non sarà in grado di lanciare IHandleEvent<EventThree>-IHandleEvent<IEvent> perché IHandleEvent<T> non è una covariante è possibile aggiungerlo aggiungendo il modificatore out.

public interface IHandleEvent<out TEvent> 
    where TEvent : IEvent 
{ } 

Purtroppo Autofac non supporta il tipo covariante ma solo di tipo controvariante. A proposito è possibile creare un'implementazione personalizzata IRegistrationSource per avere il comportamento richiesto. Qualcosa di simile a questo:

public class CovariantHandleEventRegistrationSource : IRegistrationSource 
{ 
    public bool IsAdapterForIndividualComponents 
    { 
    get 
    { 
     return false; 
    } 
    } 

    public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, 
           Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) 
    { 
    IServiceWithType typedService = service as IServiceWithType; 
    if (typedService == null) 
    { 
     yield break; 
    } 

    if (typedService.ServiceType.IsGenericType && typedService.ServiceType.GetGenericTypeDefinition() == typeof(IHandleEvent<>)) 
    { 
     IEnumerable<IComponentRegistration> eventRegistrations = registrationAccessor(new TypedService(typeof(IEvent))); 

     foreach (IComponentRegistration eventRegistration in eventRegistrations) 
     { 
     Type handleEventType = typeof(IHandleEvent<>).MakeGenericType(eventRegistration.Activator.LimitType); 
     IComponentRegistration handleEventRegistration = RegistrationBuilder.ForDelegate((c, p) => c.Resolve(handleEventType, p)) 
              .As(service) 
              .CreateRegistration(); 

     yield return handleEventRegistration; 
     } 
    } 
    } 
} 

Con questo IRegistrationSource si può avere questo:

ContainerBuilder builder = new ContainerBuilder(); 
builder.RegisterType<EventOne>().As<IEvent>(); 
builder.RegisterType<EventTwo>().As<IEvent>(); 
builder.RegisterType<EventThree>().As<IEvent>(); 
builder.RegisterAssemblyTypes(typeof(Program).Assembly) 
     .AsClosedTypesOf(typeof(IHandleEvent<>)); 

builder.RegisterSource(new CovariantHandleEventRegistrationSource()); 

IContainer container = builder.Build(); 

var x = container.Resolve<IEnumerable<IHandleEvent<IEvent>>>();