Question: I've found a method using reflection (and got it's `MethodInfo`). How can I invoke it without getting `TargetInvocationException` when exceptions are thrown?

**Update**

I'm creating a command implementation where the commands are handled by classes which implemement

```
public interface ICommandHandler<T> where T : class, ICommand
{
    public void Invoke(T command);
}

```

Since there is one dispatcher which takes care of find and map all handlers to the correct command I can't invoke the methods directly but by using reflection. Something like:

```
var handlerType = tyepof(IHandlerOf<>).MakeGenericType(command.GetType());
var method = handlerType.GetMethod("Invoke", new [] { command.GetType() });
method.Invoke(theHandler, new object[]{command});

```

It works fine, but I want all exceptions to get passed on to the code that invoked the command.

So that the caller can use:

```
try
{
    _dispatcher.Invoke(new CreateUser("Jonas", "Gauffin"));
}
catch (SomeSpecificException err)
{
    //handle it.
}

```

Instead of having to catch `TargetInvocationException`.

(I know that I can throw the inner exception, but that's pretty worthless since the stack trace is destroyed)

**Update2**

[Here](http://timwi.blogspot.se/2010/03/dynamic-method-invocation-without.html) is a possible solution..

But it seems more like a hack. Aren't there a better solution? Maybe with expressions or something?

Answer: 
Create a `Delegate` from the `MethodInfo` (through one of the overloads of [`Delegate.CreateDelegate`](http://msdn.microsoft.com/en-us/library/system.delegate.createdelegate.aspx)) and invoke that instead. This *won't* wrap any exception thrown by the method inside a `TargetInvocationException` like `MethodInfo.Invoke` does. 

```
class Foo
{
    static void ThrowingMethod()
    {
        throw new NotImplementedException();
    }

    static MethodInfo GetMethodInfo()
    {
        return typeof(Foo)
                .GetMethod("ThrowingMethod", BindingFlags.NonPublic | BindingFlags.Static);
    }

    // Will throw a NotImplementedException
    static void DelegateWay()
    {
        Action action = (Action)Delegate.CreateDelegate
                                    (typeof(Action), GetMethodInfo());
        action();
    }

    // Will throw a TargetInvocationException 
    // wrapping a NotImplementedException
    static void MethodInfoWay()
    {
        GetMethodInfo().Invoke(null, null);
    }
}

```

**EDIT**:

(As the OP has pointed out, DynamicInvoke won't work here since it wraps too)

Based on your update, I would just use `dynamic`:

```
((dynamic)theHandler).Invoke(command);

```
You can call Invoke on the mehtodinfo instance, but the first argument of the call is the target (The object that the method info belongs to). If you pass this and it has access to call it, you should not get the exception.