Marten async event handler prototype

EventHandlerDispatcher.cs

    public static class StoreOptionsExtensions
    {
        public static void AddAsyncEventHandlers(this StoreOptions options, Func<Type, IEnumerable<object>> handlerFactory)
        {
            options.Listeners.Add(new EventDispatcher(handlerFactory));
        }
    }

    public class EventDispatcher : DocumentSessionListenerBase
    {
        private readonly Func<Type, IEnumerable<object>> _handlerFactory;

        public EventDispatcher(Func<Type, IEnumerable<object>> handlerFactory)
        {
            _handlerFactory = handlerFactory;
        }

        public override Task BeforeSaveChangesAsync(IDocumentSession session, CancellationToken token)
        {
            var events = GetEvents(session);
            return Task.WhenAll(events.SelectMany(group =>
            {
                var handlerType = typeof(IAsyncEventHandler<>).MakeGenericType(group.Key);
                var handlers = _handlerFactory(handlerType) ?? Enumerable.Empty<object>();
                return handlers.SelectMany(h => 
                        group.Select(ev => 
                            (Task) handlerType.InvokeMember("Handle", BindingFlags.InvokeMethod, null, h, new[] {ev, session, token})));
            }));
        }

        private static IEnumerable<IGrouping<Type, object>> GetEvents(IDocumentSession session)
        {
            var streams = session.PendingChanges.Streams();
            return streams.SelectMany(s => s.Events).Select(e => e.Data).GroupBy(e => e.GetType());
        }
    }
    
    public interface IAsyncEventHandler<in T>
    {
        Task Handle(T @event, IDocumentSession session, in CancellationToken token);
    }

/// Create event handler
    public class MyHandler : IAsyncEventHandler<MyEvent>
    {
        public Task Handle(MyEvent @event, IDocumentSession session, in CancellationToken token)
        {
            // Do something async to handle the event
            return Task.CompletedTask;
        }
    }    


/// Setting up
   public class Startup
   {
       private IServiceProvider _provider; 

       public void ConfigureServices(IServiceCollection services)
       {
           var docStore = DocumentStore.For(x =>
           {
               x.AddAsyncEventHandlers(t =>  _provider.GetServices(t));
               // other config
           }
           services.AddTransient<IAsyncEventHandler<MyEvent, MyHandler>();
           services.AddSingleton(docStore);
           _provider = services..BuildServiceProvider();
       }
   }