It's possible to read an [Attribute] from a "NotificationHandler" in PublishCore method?

[igorgomeslima]

I've the following code structure to decide if a INotificationHandler.Handle method needs to run like a "background job":

BackgroundExecutionAttribute.cs

public class BackgroundExecutionAttribute : Attribute { }

CustomNotification.cs

public abstract record CustomNotification(string Id) : INotification;

UserCreated.cs

public record UserCreated(string Id) : CustomNotification(Id);

BaseNotificationHandler.cs

public abstract class BaseNotificationHandler<TNotification> :  INotificationHandler<TNotification> where TNotification : CustomNotification
{
    private readonly IBackgroundJobClient _backgroundJobClient; //<- Hangfire

    public BaseNotificationHandler(IBackgroundJobClient backgroundJobClient)
    {
        _backgroundJobClient = backgroundJobClient;
    }
    
    public abstract Task Handle(TNotification notification, CancellationToken cancellationToken);

    Task INotificationHandler<TNotification>.Handle(TNotification notification, CancellationToken cancellationToken)
    {
        var runsInBackground = GetType().GetCustomAttribute<BackgroundExecutionAttribute>() is not null;

        if (runsInBackground)
        {
            // Hangfire job...
            _backgroundJobClient.Create
            (
                state: new EnqueuedState("default"),
                methodCall: () => Handle(notification, cancellationToken)
            );
        }
        else
        {
            Handle(notification, cancellationToken);
        }

        return Task.CompletedTask;
    }
}

SendEmailAferUserCreationNotificationHandler .cs

[BackgroundExecution]
public class SendEmailAferUserCreationNotificationHandler : BaseNotificationHandler<UserCreated>
{
    public SendEmailAferUserCreationNotificationHandler(IBackgroundJobClient backgroundJobClient) : base(backgroundJobClient) { }

    public override Task Handle(UserCreated notification, CancellationToken cancellationToken) => Task.CompletedTask;
}

But I want to do this decision "more close" to the "real method call", to maybe catch exceptions, etc... something like:

public class MyMediatR : Mediator
{
    private readonly ServiceFactory _serviceFactory;
    private readonly IBackgroundJobClient _backgroundJobClient;

    public MyMediatR(ServiceFactory serviceFactory, IBackgroundJobClient backgroundJobClient) : base(serviceFactory)
    {
        _serviceFactory = serviceFactory;
        _backgroundJobClient = backgroundJobClient;
    }

    protected override async Task PublishCore(IEnumerable<Func<INotification, CancellationToken, Task>> allHandlers, INotification notification, CancellationToken cancellationToken)
    {
        foreach (var handler in allHandlers)
        {
            try
            {
                var isBackgroundExecution = handler.GetCustomAttribute<BackgroundExecutionAttribute>() is not null; // This line does not compile...

                //var isBackgroundExecution = handler.Target.GetType().GetCustomAttribute<BackgroundExecutionAttribute>() is not null; // Returns false...
                
                if (isBackgroundExecution)
                {
                    // Hangfire job...
                    _backgroundJobClient.Create
                    (
                        state: new EnqueuedState("default"),
                        methodCall: () => handler(notification, cancellationToken)
                    );
                }
                else
                {
                    await handler(notification, cancellationToken);
                }
            }
            catch (Exception e)
            {
                //Do something...
                throw;
            }
        }
    }
}

That way I don't need to require an instance of IBackgroundJobClient for everyone who inherits from BaseNotificationHandler, like:

public SendEmailAferUserCreationNotificationHandler(IBackgroundJobClient backgroundJobClient) : base(backgroundJobClient) { }

To:

public SendEmailAferUserCreationNotificationHandler() { }

Can I get an specific attribute from in this overloaded method(like from handler on foreach loop)? It's a good idea?

Thanks for any review/help.

Cheers! 🙌