Generic event handlers
You can create handlers that are invoked for all events.
To do that you have to create an open generic class implementing the IEventHandler<TEvent>
interface.
See Events usage for details.
For example this event handler will be invoked for all events:
/// <summary>
/// This class catchs all events
/// </summary>
public class GenericEventHandler<T> : IEventHandler<T> where T : IEvent
{
private readonly ILogger<GenericEventHandler<T>> _logger;
public GenericEventHandler(ILogger<GenericEventHandler<T>> logger)
{
_logger = logger;
}
public Task Handle(T @event, CancellationToken cancellationToken)
{
_logger.LogDebug("Received event: ", @event);
return Task.CompletedTask;
}
}
Another example. Imagine that you have an abstract class called BaseEvent
for some events in your app,
and you want to create a handler that is only invoked for all events that are derived from BaseEvent.
This will do the trick:
public abstract class BaseEvent : IEvent
{
public Guid EventId { get; }
public BaseEvent()
{
EventId = Guid.NewGuid();
}
}
/// <summary>
/// This class catchs all BaseEvent derived events
/// </summary>
public class BaseEventGenericHandler<T> : IEventHandler<T> where T : BaseEvent
{
private readonly ILogger<BaseEventGenericHandler<T>> _logger;
public BaseEventGenericHandler(ILogger<BaseEventGenericHandler<T>> logger)
{
_logger = logger;
}
public Task Handle(T @event, CancellationToken cancellationToken)
{
_logger.LogDebug("Received base event derived event: ", @event);
return Task.CompletedTask;
}
}
Important
This depends on the DI container support for generic variance.