autofac開いているジェネリックタイプのすべてのタイプを解決しますか？

Question

私はAutofacで次のようなことをする方法がないと思っています。開いているジェネリック型の列挙可能なコレクションを挿入する必要がありますか？さまざまなHandle型は依存関係があります。そうでなければ、動的にそれらを構築します。

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

としては、コメントで説明し、何が欲しいのはC＃で正当な理由で達成することは不可能です。 IHandleEvent<EventOne>をIHandleEvent<IEvent>にキャストできた場合は、EventTwoも渡すことができ、実行時には失敗します。

したがって、互換性のあるすべてのイベントハンドラを取得して呼び出すことができるメディエータの抽象化が必要です。このような仲介者はしばしばIEventPublisherと呼ばれ、次のようになります。

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

あなたは今、コンテナ特定の実装を作成することができます。例えば、これはなりAutofacために、次のように：

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))); 
} 

消費者は今、この新しい抽象化に依存することができます

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

Answer 2

IHandleEvent<T>あなたはout修飾子を追加することによって、それを追加することができます共変ではありませんので、あなたはIHandleEvent<IEvent>にIHandleEvent<EventThree>をキャストすることはできません。

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

残念ながらAutofacは共変タイプだけ反変タイプをサポートしていません。 ところで、カスタムのIRegistrationSource実装を作成して、要求された動作をさせることができます。このような何か：

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; 
     } 
    } 
    } 
} 

このIRegistrationSourceでは、あなたがこれを持つことができます。

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