How can I wrap mediator return types?

Question

I want my handlers to always return IDispatchResult<TResponse>, but I don't know how to get an IPipelineBehavior to work.

For example, this standard code works fine...

internal class Program
{
    static async Task Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddMediatR(x => x
            .RegisterServicesFromAssemblyContaining<Program>()
            .AddBehavior(typeof(IPipelineBehavior<,>), typeof(MyValidator<,>), ServiceLifetime.Scoped));

        IServiceProvider serviceProvider = services.BuildServiceProvider().CreateScope().ServiceProvider;
        IMediator mediator = serviceProvider.GetRequiredService<IMediator>();

        MyResponse response = await mediator.Send(new MyCommand());
    }
}

public class MyValidator<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    public Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        Console.WriteLine("Middleware executed.");
        return next();
    }
}

public class MyCommand : IRequest<MyResponse> { }
public class MyResponse { }
public class MyCommandHandler : IRequestHandler<MyCommand, MyResponse>
{
    public Task<MyResponse> Handle(MyCommand request, CancellationToken cancellationToken)
    {
        Console.WriteLine("Handler executed.");
        throw new NotImplementedException();
    }
}

But now I want all of my responses to be wrapped in IDispatchResult<TResponse> so I can provide more context about the TResponse - such as a success status, or a list of validation errors, etc.

My middleware in the following example does not get executed, can anyone tell me how to fix this?

internal class Program
{
    static async Task Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddScoped<IDispatcher, Dispatcher>();
        services.AddMediatR(x => x
            .RegisterServicesFromAssemblyContaining<Program>()
            .AddBehavior(typeof(IPipelineBehavior<,>), typeof(MyValidator<,>), ServiceLifetime.Scoped));

        IServiceProvider serviceProvider = services.BuildServiceProvider().CreateScope().ServiceProvider;
        var dispatcher = serviceProvider.GetRequiredService<IDispatcher>();

        IDispatchResult<MyResponse> response = await dispatcher.Send<MyCommand, MyResponse>(new MyCommand());
        Console.WriteLine(response is IDispatchResult<object>);
        Console.ReadLine();
    }
}

public class MyValidator<TRequest, TResponse> : IPipelineBehavior<TRequest, IDispatchResult<TResponse>>
    where TRequest : IRequest<IDispatchResult<TResponse>>
    where TResponse : class
{
    public Task<IDispatchResult<TResponse>> Handle(TRequest request, RequestHandlerDelegate<IDispatchResult<TResponse>> next, CancellationToken cancellationToken)
    {
        Console.WriteLine("Middleware executed");
        return next();
    }
}

public class MyCommand : IRequest<IDispatchResult<MyResponse>> { }
public class MyResponse { }
public class MyCommandHandler : IRequestHandler<MyCommand, IDispatchResult<MyResponse>>
{
    public async Task<IDispatchResult<MyResponse>> Handle(MyCommand request, CancellationToken cancellationToken)
    {
        await Task.Yield();
        Console.WriteLine("Handler executed");
        return new DispatchOKResult<MyResponse>(new MyResponse());
    }
}

public interface IDispatchResult<out TPayload> where TPayload: class
{
    public TPayload? Payload { get; }
}

public class DispatchOKResult<TPayload> : IDispatchResult<TPayload> where TPayload: class
{
    public TPayload? Payload { get; set; }

    public DispatchOKResult(TPayload? payload)
    {
        Payload = payload;
    }
}

public interface IDispatcher
{
    Task<IDispatchResult<TResponse>> Send<TRequest, TResponse>(TRequest request)
        where TRequest : IRequest<IDispatchResult<TResponse>>
        where TResponse : class;
}

public class Dispatcher : IDispatcher
{
    private readonly IMediator Mediator;

    public Dispatcher(IMediator mediator)
    {
        Mediator = mediator;
    }

    public Task<IDispatchResult<TResponse>> Send<TRequest, TResponse>(TRequest request)
        where TRequest : IRequest<IDispatchResult<TResponse>>
        where TResponse: class
        => Mediator.Send(request);

}

Answer 1

Your Behavior type does not match the Handler type, thus it is not executed.

First of all, you should register generic Behaviors with the AddOpenBehavior() call:

.AddOpenBehavior(typeof(MyValidator<,>))

To get it to match the type of the Handler I had to modify it as such:

public class MyValidator<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TRequest : IRequest<TResponse>
where TResponse : IDispatchResult<object>
{
    public Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        Console.WriteLine("Middleware executed");
        return next();
    }
}