MediatR distinguish handlers by Attribute

Considering to migrate my custom written CQRS framework to MediatR while transitioning from asp.net to asp.net.core.

    public interface IQueryDispatcher
    {
        Task<TResult> Dispatch<TParameter, TResult>(TParameter query = null)
            where TParameter : class, IQuery, new()
            where TResult : IQueryResult;

        Task<TResult> **DispatchForModule**<TParameter, TResult>(MyModule module, TParameter query = null)
            where TParameter : class, IQuery, new()
            where TResult : IQueryResult;
    }

The issue I’m facing is the ability to dispatch queries/commands based on attribute attached to a handler.

    [ModuleSpecific(MyModule.Bananas)]
    public class RemoveRecordCommandHandler : ICommandHandler<RemoveRecordCommand>
    {
    ...
    }

The solution domain is split into modules which all have a base set of commands and queries. I would otherwise call something like

    canEdit = _query.DispatchForModule(MyModule.Apples, new CanEditRecordQuery{Id = 10});
    ...
    _command.DispatchForModule(MyModule.Bananas, new RemoveRecordCommand{Id = 20})

How does MediatR deal with multiple handler implementations for the equal type parameters of commands or queries.

[jbogard]

Handler duplication is no different than any other kind of duplication - if two handlers share the same set of code, refactor that code into some sort of shared function/class. You don’t need to have some additional redirection in a mediator to deal with duplication. It’s no different than two controller actions, or message handlers, or service classes etc. that have duplication.

MediatR enforces a single handler per request which FORCES you to deal with the duplication in any one of the dozen or so vanilla refactoring techniques. Do that, not some additional redirection that’s even harder to connect the dots to than the mediator pattern already.

[apylypchuk]

It’s plugin based system with modules, and nothing to do with code duplication apart from interface signature of the handlers, which will implement conceptually similar but far from duplicate logic.

Each module is then a set of handlers that implement same interfaces.

I was not asking for guidance on avoiding ctrl-c, ctrl-p, but checking if there are other strategies to resolve those implementations, rather then that which strictly looks into the query/result types.

Anyways, ended up with my custom query/command dispatchers with decorators.

    [Area(Action.Module.Name)]
    public class ModuleFilterHandler : ModuleFilterHandlerBase, IQueryHandler<FilteringQuery, FilteringQueryResult>

    [Area(Incident.Module.Name)]
    public class ModuleFilterHandler : ModuleFilterHandlerBase, IQueryHandler<FilteringQuery, FilteringQueryResult>

and then

        [HttpPost("[action]")]
        public async Task<ActionResult<FilteringQueryResult>> FilterResult([FromBody]FilteringQuery query)
        {
            FilteringQueryResult result = await _queryDispatcher.SendToArea<FilteringQuery, FilteringQueryResult>(query.Module, query);
            return result;
        }