Autofac how to register and resolve generic interface at runtime?

Question

I am having trouble resolving a generic interface implementation at runtime. I am working with an eventbus that will resolve eventhandlers depending on the type of the event. When I try to resolve the eventhandlers without a generic implementation everything works as expected. I want to implement a generic interface so I could have a base class that handles specific type of events.

I had the following situation before I created a generic implementation:

public interface IEvent
    {
        Guid EntityId { get; set; }
    }

public interface IEventHandler<TEvent> where TEvent : IEvent
    {
        Task Handle(TEvent @event);
    }

public class EventBus
    {
        private readonly IComponentContext _context;

        public EventBus(IComponentContext context)
        {
            _context = context;
        }

        public async Task HandleEvent<TEvent>(TEvent @event) where TEvent : IEvent
        {
            var handler = _context.Resolve<IEventHandler<TEvent>>();
            await handler.Handle(@event);
        }
    }

I register the eventHandlers as follows:

builder.RegisterAssemblyTypes(ThisAssembly).AsClosedTypesOf(typeof(IEventHandler<>));

Example Implementation :

public class FooEventHandler :
        IEventHandler<FooArchivedEvent>,
        IEventHandler<FooRestoredEvent>,
        IEventHandler<FooSomethingElseHappenedEvent>
    {
        private readonly IRepository<Foo> _repository;

        public FooEventHandler(IRepository<Foo> repository)
        {
            _repository = repository;
        }

        public async Task Handle(FooArchivedEvent @event)
        {
            var Foo = await _repository.Get(@event.EntityId);
            Foo.Archive();
        }

        public async Task Handle(FooRestoredEvent @event)
        {
            var Foo = await _repository.Get(@event.EntityId);
            Foo.Restore();
        }

        public async Task Handle(FooSomethingElseHappenedEvent @event)
        {
            // do something else with Foo
        }
    }

    public class BarEventHandler :
        IEventHandler<BarArchivedEvent>,
        IEventHandler<BarRestoredEvent>
    {
        private readonly IRepository<Bar> _repository;

        public BarEventHandler(IRepository<Bar> repository)
        {
            _repository = repository;
        }

        public async Task Handle(BarArchivedEvent @event)
        {
            var Bar = await _repository.Get(@event.EntityId);
            Bar.Archive();
        }

        public async Task Handle(BarRestoredEvent @event)
        {
            var Bar = await _repository.Get(@event.EntityId);
            Bar.Restore();
        }
    }

When I pass a FooArchivedEvent to the eventbus the eventbus will resolve the required eventhandler. As you can see I have some duplicate code that I want to resolve in a base eventhandler. This is what I tried before I created the generic implementation (which won't compile):

public class BaseEventHandler<TEntity, TArchivedEvent, TRestoredEvent> :
        IEventHandler<TArchivedEvent>,
        IEventHandler<TRestoredEvent>
        where TEntity : class
        where TArchivedEvent : IEvent
        where TRestoredEvent : IEvent
    {
        public Task Handle(TArchivedEvent @event)
        {
            throw new NotImplementedException();
        }

        public Task Handle(TRestoredEvent @event)
        {
            throw new NotImplementedException();
        }
    }

So I created a generic base class that does compile, however I can't figure out how to resolve the generic eventhandler in the eventbus. Generic base class:

public abstract class BaseEventHandler<TEntity> :
        IEventHandler<IArchivedEvent<TEntity>>,
        IEventHandler<IRestoredEvent<TEntity>>
        where TEntity : Archivable
    {
        protected readonly IRepository<TEntity> _repository;

        public BaseEventHandler(IRepository<TEntity> repository)
        {
            _repository = repository;
        }

        public virtual async Task Handle(IArchivedEvent<TEntity> @event)
        {
            var entity = await _repository.Get(@event.EntityId);
            entity.Archive();
        }

        public async virtual Task Handle(IRestoredEvent<TEntity> @event)
        {
            var entity = await _repository.Get(@event.EntityId);
            entity.Archive();
        }
    }

My new FooEventHandler will now look like this:

public class FooEventHandler : BaseEventHandler<Foo>,
        IEventHandler<FooSomethingElseHappenedEvent>
    {
        public FooEventHandler(IRepository<Foo> repository) : base(repository)
        {
        }

        public Task Handle(FooSomethingElseHappenedEvent @event)
        {
            // do something else with Foo
        }
    }

Now when I pass a FooArchivedEvent to the eventbus the eventbus can't resolve the eventhandler. Is there something I need to do in the registration part or is it not possible to resolve a generic implementation like this ?

Answer 1

I ended up writing a method that checks every interface of a type for a registered handler:

private IEventHandler<TEvent> GetHandler<TEvent>(Type type = null) where TEvent : IEvent
        {
            object handler;
            type = type ?? typeof(TEvent);
            if (_container.TryResolve(typeof(IEventHandler<>).MakeGenericType(type), out handler))
            {
                return (IEventHandler<TEvent>)handler;
            }
            else
            {
                foreach (var t in type.GetInterfaces())
                {
                    var h = GetHandler<TEvent>(t);
                    if (h != null)
                        return h;
                }
            }
            return null;
        }