Why not generating overloads of the Send method rather than using a switch?

[GiottoVerducci]

I'm asking this because I use Mapperly which does generate multiple method (by design, because you only declare a partial method, and it generates the code for it) and when I look at the code generated by Mediator, it becomes quickly slow to navigate.

So instead of

   public global::System.Threading.Tasks.ValueTask<TResponse> Send<TResponse>(
       global::Mediator.IRequest<TResponse> request,
       global::System.Threading.CancellationToken cancellationToken = default
   )
   {
       switch (request)
       {
           case global::DeleteCommand r:
           {
               if (typeof(TResponse) == typeof(global::Foo))
               {
                   var task = Send(r, cancellationToken);
                   return global::System.Runtime.CompilerServices.Unsafe.As<global::System.Threading.Tasks.ValueTask<global::Foo>, global::System.Threading.Tasks.ValueTask<TResponse>>(ref task);
               }
               return SendAsync(request, cancellationToken);
           }
           case global::GetQuery r:
           {
               if (typeof(TResponse) == typeof(global::Foo))
               {
                   var task = Send(r, cancellationToken);
                   return global::System.Runtime.CompilerServices.Unsafe.As<global::System.Threading.Tasks.ValueTask<global::Foo>, global::System.Threading.Tasks.ValueTask<TResponse>>(ref task);
               }
               return SendAsync(request, cancellationToken);
           }
           default:
           {
               ThrowInvalidRequest(request, nameof(request));
               return default;
           }
       }
   }

why not have two methods?

     public global::System.Threading.Tasks.ValueTask<ServerSettingsItem> Send<ServerSettingsItem>(
    DeleteCommand request,
    global::System.Threading.CancellationToken cancellationToken = default
)
    {
        var task = Send(request, cancellationToken);
        return global::System.Runtime.CompilerServices.Unsafe.As<global::System.Threading.Tasks.ValueTask<global::Foo>, global::System.Threading.Tasks.ValueTask<TResponse>>(ref task);
    }

and

     public global::System.Threading.Tasks.ValueTask<ServerSettingsItem> Send<ServerSettingsItem>(
    GetQuery request,
    global::System.Threading.CancellationToken cancellationToken = default
)
    {
        var task = Send(request, cancellationToken);
        return global::System.Runtime.CompilerServices.Unsafe.As<global::System.Threading.Tasks.ValueTask<global::Foo>, global::System.Threading.Tasks.ValueTask<TResponse>>(ref task);
    }

[GiottoVerducci]

hmm, I see that those two methods exists already. Why is the switch needed then?

[martinothamar]

So the code is generated inside the Mediator implementation, and for simple projects you can get away with always referencing that directly and as such will never use the IRequest<>/generic overloads. But sometimes, depending on project setup, you can't have all the projects needing to dispatch messages reference Mediator directly, and that's where IMediator comes in which comes from the Abstractions package. This interface can't possible know of all the different message types so that's where the generic overloads come in.

Previously there were only switch statements to dispatch messages, but now for larger projects there is a dictionary-based approach as well which becomes more efficient after a certain project size. This project started out wanting to keep as much MediatR compatibility as possible so some of other design decisions were affected by that

[GiottoVerducci]

That makes totally sense! Thanks for your answer!