autofac Giải quyết tất cả các loại kiểu generic mở?

Question

Tôi đoán không có cách nào để làm một cái gì đó như sau với Autofac, để ctor tiêm một bộ sưu tập đầy đủ các loại generic mở? Các loại Xử lý khác nhau có các phụ thuộc, nếu không tôi sẽ tự động xây dựng những thứ đó.

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

Như đã giải thích trong các ý kiến, những gì bạn muốn là không thể đạt được trong C# và với lý do chính đáng. Nếu bạn có thể truyền một số IHandleEvent<EventOne> đến một số IHandleEvent<IEvent>, điều này cũng sẽ cho phép một số EventTwo được chuyển vào, điều này sẽ không thành công khi chạy.

Vì vậy, những gì bạn cần là một trừu tượng hòa giải cho phép nhận tất cả các trình xử lý sự kiện tương thích và gọi cho họ. Hòa giải viên như vậy thường được gọi là IEventPublisher và có thể trông giống như sau:

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

Bây giờ bạn có thể tạo triển khai cụ thể cho vùng chứa. Ví dụ, đối với Autofac này sẽ trông như sau: Bây giờ

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

tiêu dùng có thể phụ thuộc vào sự trừu tượng mới này:

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

Answer 2

Bạn sẽ không thể bỏ IHandleEvent<EventThree>-IHandleEvent<IEvent> vì IHandleEvent<T> không phải là một hiệp biến bạn có thể thêm nó bằng cách thêm các modifier out.

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

Thật không may Autofac không hỗ trợ loại hiệp biến nhưng chỉ loại contravariant. Bằng cách này, bạn có thể tạo triển khai IRegistrationSource tùy chỉnh để có hành vi được yêu cầu. Một cái gì đó như thế này:

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

Với IRegistrationSource này bạn có thể có điều này:

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