Tengo una interfaz genéricaICommandHandler<> que tendrá una serie de implementaciones cada una para procesar una implementación específica deICommand, p.ej.:

public class CreateUserCommand : ICommand { ... }
public class CreateUserCommandHandler : ICommandHandler<CreateUserCommand> { ... }

Cuando me dan unICommand objeto estoy tratando de enviarlo dinámicamente a la correctaICommandHandler. En este momento he usado un enfoque de reflexión bastante sencillo con unInvoke en mi clase de despachador:

public void Dispatch<T>(T command) where T : ICommand
{
    Type commandType = command.GetType();
    Type handlerType = typeof(ICommandHandler<>).MakeGenericType(commandType);
    object handler = IoC.Get(handlerType);
    MethodInfo method = handlerType.GetMethod("Handle");

    method.Invoke(handler, new object[] { command });
}

Hay 2 problemas con este enfoque. En primer lugar utiliza la reflexión lenta. En segundo lugar, si el método arroja algún tipo de excepción, entonces se envolverá en unTargetInvocationException y perderé el rastro de pila si lo vuelvo a lanzar.

Hice una manera de hacer la llamada creando un delegado y usandoDynamicInvoke pero esto no resuelve el problema con excepciones (y no estoy seguroDynamicInvoke es realmente mejor queInvoke):

public void Dispatch<T>(T command) where T : ICommand
{
    Type commandType = command.GetType();
    Type handlerType = typeof(ICommandHandler<>).MakeGenericType(commandType);
    object handler = IoC.Get(handlerType);
    MethodInfo method = handlerType.GetMethod("Handle");

    Type actionType = typeof(Action<>).MakeGenericType(commandType);
    Delegate action = Delegate.CreateDelegate(actionType, handler, method);
    action.DynamicInvoke(command);
}

Mi pregunta es, ¿hay una mejor manera de lograr lo que estoy tratando de hacer? Preferiblemente, podría hacer una llamada fuertemente tipada en lugar de recibir una llamada.object y mirando hacia arriba elMethodInfo. Supongo que eso no es posible porque el tipo no se conoce en el momento de la compilación.

Si eso no es posible, entonces la mejor opción sería una solución eficiente que arrojara la excepción de forma más "nativa".

Editar: Ejemplos de código actualizados para aclarar que estoy usando IoC (Ninject) para crear elICommandHandler en tiempo de ejecución, noActivator.CreateInstance() como puse primero Incluyó un ejemplo de cómo se usaría según lo solicitado:

var command = new CreateUserCommand() { Name = "Adam Rodger" };
var dispatcher = new CommandDispatcher();
dispatcher.Dispatch(command);
// this would send the message to CreateUserCommandHandler.Handle(command) 
// dynamically and any exceptions would come back 'natively'

Editar 2: Como se sugiere a continuación, no puedo emitir el resultado deIoC.Get(handlerType) aICommandHandler<T> porque me sale unInvalidCastException en tiempo de ejecución. Esto es porque en el tiempo de ejecuciónT es en realidadICommand, Asumo porque las clases de comando están llegando a través de WCF y de alguna manera logran perder su escritura fuerte. El código que llama al despachador se ve algo como:

[ServiceContract]
public class CommandService
{
    [OperationContract]
    public void Execute(ICommand command) // no type information
    {
        var dispatcher = new CommandDispatcher(); // injected by IoC in real version
        dispatcher.Dispatch(command);
    }
}