Как разработать систему событий и обработчиков событий, используя универсальный код на C#?

Основная идея состоит в том, чтобы использовать отражение только для создания обработчиков и словаря от типа к обработчику. Что-то в этом роде (с использованием деревьев выражений):

public static class Helper
{
    private static readonly Dictionary<Type, IEventHandler> Handlers = new()
    {
        {typeof(TestEvent), new TestEventHandler()}
    };
    
    // not an Action<IEvent> due to static abstract member of the interface
    private static Dictionary<Type, Action<object>> HandlerFuncs = new()
    {
        {typeof(TestEvent), CreateHandler<TestEvent>()}
    };

    public static void Handle(IEvent @event) => HandlerFuncs[@event.GetType()](@event);

    private static Action<object> CreateHandler<T>()
    {
        var genericMethod = typeof(Helper)
            .GetMethod(nameof(Helper.HandleGeneric), BindingFlags.Static | BindingFlags.NonPublic)
            .MakeGenericMethod(typeof(T));

        var parameterExpression = Expression.Parameter(typeof(object));
        var expression = Expression.Lambda<Action<object>>(Expression.Call(genericMethod, parameterExpression), parameterExpression);
        return expression.Compile();
    }

    private static void HandleGeneric<T>(object @event) where T : class, IEvent
    {
        var eventHandler = Handlers[typeof(T)] as IEventHandler<T>;
        eventHandler.HandleEvent((T)@event);
    }
}

Звонок выглядит так: Helper.Handle(new TestEvent());.

И Handlers, и HandlerFuncs можно создать с помощью отражения и/или поставщика услуг, я использую словари, создаваемые вручную, только в демонстрационных целях. Вы также можете использовать стороннюю библиотеку, например Scrutor, чтобы уменьшить количество отражений, которые необходимо писать вручную.

Его можно относительно легко обновить для работы с DI. Например:

public class HandlerInvoker
{
    private static readonly ConcurrentDictionary<Type, Action<IServiceProvider, object>> handlerFuncs = new();
    
    private readonly IServiceProvider _serviceProvider;

    public HandlerInvoker(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    public void HandleEvent(IEvent e)
    {
        var handler = handlerFuncs.GetOrAdd(e.GetType(), CreateHandler);
        handler(_serviceProvider, e);
    }
    
    private static Action<IServiceProvider, object> CreateHandler(Type t)
    {
        var genericMethod = typeof(HandlerInvoker)
            .GetMethod(nameof(HandleGeneric), BindingFlags.Static | BindingFlags.NonPublic)
            .MakeGenericMethod(t);

        var p1 = Expression.Parameter(typeof(IServiceProvider));
        var p2 = Expression.Parameter(typeof(object));
        var expression = Expression.Lambda<Action<IServiceProvider, object>>(Expression.Call(genericMethod, p1, p2), p1, p2);
        return expression.Compile();
    }
    
    private static void HandleGeneric<T>(IServiceProvider sp, object @event) where T : class, IEvent
    {
        var eventHandler =sp.GetRequiredService<IEventHandler<T>>();
        eventHandler.HandleEvent((T)@event);
    }
}

И пример использования:

var services = new ServiceCollection();
services.AddTransient<IEventHandler<TestEvent>, TestEventHandler>();
services.AddTransient<HandlerInvoker>();
var sp = services.BuildServiceProvider();

var handlerInvoker = sp.GetService<HandlerInvoker>();
handlerInvoker.HandleEvent(new TestEvent());

В зависимости от варианта использования деревья отражений и выражений могут быть заменены генераторами источников.