MissingMessageHandlerException when passing derived class to Send

[Xpl0itR]

I understand why this doesn't work, but would it be possible to implement support for this?

This is my use-case:

In domain project (with Mediator.Abstractions)

public interface IMyReq : IRequest<string>
{
    string MyParam { get; }
}

public sealed class MyReqHandler : IRequestHandler<IMyReq, string>
{
    // implementation...
    public ValueTask<string> Handle(IMyReq req, CancellationToken ct)
    {
        // implementation...
    }
}

In asp.net application project (with Mediator.SourceGenerator)

public sealed record MyReq : IMyReq
{
    [FromQuery]
    public required string MyParam { get; init; }
}

public static partial class Endpoints
{
    public static void MapEndpoints(this IEndpointRouteBuilder endpoints)
    {
        endpoints.MapGet("/my_endpoint", (IMediator mediator, [AsParameters] MyReq req) => mediator.Send((IMyReq)req));
        // ...
    }
}

[feiyun0112]

because handler member should by class

https://github.com/martinothamar/Mediator/blob/5b500ad9bd61606d96b0e8ab045a5a6eff1499f5/src/Mediator.SourceGenerator.Implementation/Analysis/CompilationAnalyzer.cs#L442C64-L442C64

[CheloXL]

Mmm.. I don't think that's the problem. First because records are classes (unless it's a struct record). Second, because I'm already using records as commands and it works just fine.
So, the issue must be anything else, maybe related to the use of an interface?

[Xpl0itR]

I believe feiyun0112 is correct, but it would be nice to support interfaces or abstract classes

[martinothamar]

Even if the source generator filters out the interface itself (like @feiyun0112 says), it still is able to find the concrete requests deriving from IMyReq, but the source generator doesn't currently match it with a handler, since it expects the type parameters to match. There might be a way to make the source generator support this, when doing the message -> handler matching, use the most concrete message/handler combination where possible, but I'm not sure if it's worth it.

I guess the practical difference in the end would be

public sealed class MyReqHandler : IRequestHandler<IMyReq, string>
{
    public ValueTask<string> Handle(IMyReq req, CancellationToken ct)
    {
        switch (req)
        {
            // ...
        }
    }
}

vs

public sealed class ConcreteReq1Handler : IRequestHandler<ConcreteReq1, string>
{
    public ValueTask<string> Handle(ConcreteReq1 req, CancellationToken ct)
    {    }
}
public sealed class ConcreteReq2Handler : IRequestHandler<ConcreteReq2, string>
{
    public ValueTask<string> Handle(ConcreteReq2 req, CancellationToken ct)
    {    }
}

So I think the implementation and maintenance cost outweigh the benefit in this case