I have some troubles with Custom Pipeline Behavior in .NET MAUI using MediatR

Question

I'm working on a .NET MAUI application and have implemented a custom pipeline behavior using MediatR, but I'm facing issues with it not being called as expected. I've outlined my implementation below and would appreciate any insights, advices, or suggestions to resolve this issue.

Pipeline Behavior:

public class ExceptionsPipelineBehavior<TRequest, TResponse>(
        IDateTimeProvider dateTimeProvider,
        INetwork network,
        ILogger logger)
    : IPipelineBehavior<TRequest, TResponse>
where TRequest : IBaseRequest<TResponse>
where TResponse : Result
{
    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        var requestTypeName = typeof(TRequest).Name.Replace("Request", "");
        dynamic response = typeof(TResponse);

        if (!network.Connected())
        {
            return response.Failure(DomainErrors.NotNetwork(requestTypeName));
        }

        logger.LogTrace("Starts Handling {@RequestType}, {@DateTime}", requestTypeName, dateTimeProvider.UtcNow);

        try
        {
            response = await next();

            logger.LogTrace("Ends Handling {@RequestType}, {@DateTime}", requestTypeName, dateTimeProvider.UtcNow);

            return response;
        }
        catch (HttpRequestException ex)
        {
            logger.LogError(ex, "Error Handling {@RequestType}, {@DateTime}", requestTypeName, dateTimeProvider.UtcNow);

            var error = ex.StatusCode switch
            {
                HttpStatusCode.BadRequest => Error.Failure(),
                HttpStatusCode.Unauthorized => Error.Unauthorized(),
                HttpStatusCode.Forbidden => Error.Failure(),
                HttpStatusCode.NotFound => Error.NotFound(),
                HttpStatusCode.Conflict => Error.Conflict(),
                HttpStatusCode.InternalServerError => DomainErrors.ServiceIsUnavailable,
                _ => DomainErrors.ServiceIsUnavailable,
            };

            return response.Failure(error);
        }
    }
}

Setup:

services
    .AddMediatR(config =>
    {
        config.RegisterServicesFromAssemblies(AssemblyReference.Assemblies);
        config.NotificationPublisher = new TaskWhenAllPublisher();
    });
services
    .AddTransient(
        typeof(IPipelineBehavior<,>),
        typeof(ExceptionsPipelineBehavior<,>));

Is there anything in my implementation of ExceptionsPipelineBehavior<TRequest, TResponse> that could be causing it not to be called as expected? Are there any known issues with custom pipeline behaviors in .NET MAUI with MediatR that I should be aware of?

I have already used the OpenBehavior method in MediatR configuration.

Also, I have already checked my network service, logging setup, and made sure that the behavior is registered correctly, but the behavior still isn't triggered. Any advice or suggestions would be greatly appreciated!

Best,

Answer 1

According to the docs, you need to register the behavior in the AddMediatR() call:

config.AddOpenBehavior(typeof(ExceptionsPipelineBehavior<,>));

Your call to AddTransient is unnecessary.

EDIT: I wrote this example to show you how you can approach this problem. I think this is what you are trying to do. This has a slight drawback of checking for types at runtime for every request so it might affect performance slightly.

I also tried coming up with a compile-time solution but the IoC container would not resolve the types the way I wanted. Please check out this article to have a better understanding.

using MediatR;
using Microsoft.Extensions.DependencyInjection;

var serviceCollection = new ServiceCollection();

serviceCollection.AddMediatR(config =>
{
    config.RegisterServicesFromAssembly(typeof(Program).Assembly);
    config.AddOpenBehavior(typeof(Behavior<,>));
});

var serviceProvider = serviceCollection.BuildServiceProvider();

var mediator = serviceProvider.GetRequiredService<IMediator>();

await mediator.Send(new EmptyRequest());
await mediator.Send(new NumberRequest() { Number = 15 });
await mediator.Send(new OtherRequest());

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

interface IBaseRequest { }
abstract class BaseRequest<T> : IBaseRequest, IRequest<T> where T : BaseResponse { }
class BaseResponse { }
class EmptyRequest : BaseRequest<BaseResponse> { }
class NumberRequest : BaseRequest<NumberResponse> { public int Number { get; set; } }
class NumberResponse : BaseResponse { public int Number { get; set; } }
class OtherRequest : IRequest<int> { }

class NumberRequestHandler : IRequestHandler<NumberRequest, NumberResponse>
{
    public Task<NumberResponse> Handle(NumberRequest request, CancellationToken cancellationToken)
    {
        Console.WriteLine("Number handler executed.");
        return Task.FromResult(new NumberResponse() { Number = request.Number + 1 });
    }
}

class EmptyRequestHandler : IRequestHandler<EmptyRequest, BaseResponse>
{
    public Task<BaseResponse> Handle(EmptyRequest request, CancellationToken cancellationToken)
    {
        Console.WriteLine("Empty Handler executed.");
        return Task.FromResult(new BaseResponse());
    }
}
class OtherRequestHandler : IRequestHandler<OtherRequest, int>
{
    public Task<int> Handle(OtherRequest request, CancellationToken cancellationToken)
    {
        Console.WriteLine("Other Handler executed.");
        return Task.FromResult(0);
    }
}