Ответ 1

Вот решение, которое я придумал. Он выполняет свою работу. Меня все еще интересуют другие ответы, поскольку может быть что-то проще или чище.

• Если вам нужна функциональность throw;, но исключение, которое вы хотите передать, не является исключением текущего блока catch, используйте throw Functional.Rethrow(e);
• Замените try...catch... на Functional.TryCatch
• Замените try...catch...finally... на Functional.TryCatchFinally

Здесь код:

//Need a dummy type that is throwable and can hold an Exception
public sealed class RethrowException : Exception
{
    public RethrowException(Exception inner) : base(null, inner) { }
}

public static Functional
{    
    public static Exception Rethrow(Exception e)
    {
        return new RethrowException(e);
    }

    public static void TryCatch(Action _try, Action<Exception> _catch)
    {
        try { _try(); }
        catch (RethrowException e) { _catch(e.InnerException); }
        catch (Exception e) { _catch(e); }
    }

    public static T TryCatch<T>(Func<T> _try, Func<Exception, T> _catch)
    {
        try { return _try(); }
        catch (RethrowException e) { return _catch(e.InnerException); }
        catch (Exception e) { return _catch(e); }
    }

    public static void TryCatchFinally(
        Action _try, Action<Exception> _catch, Action _finally)
    {
        try { _try(); }
        catch (RethrowException e) { _catch(e.InnerException); }
        catch (Exception e) { _catch(e); }
        finally { _finally(); }
    }

    public static T TryCatchFinally<T>(
        Func<T> _try, Func<Exception, T> _catch, Action _finally)
    {
        try { return _try(); }
        catch (RethrowException e) { return _catch(e.InnerException); }
        catch (Exception e) { return _catch(e); }
        finally { _finally(); }
    }
}

Update

В .NET 4.5 есть новый класс System.Runtime.ExceptionServices.ExceptionDispatchInfo. Это можно использовать для захвата исключения:

var capturedException = ExceptionDispatchInfo.Capture(e);

И затем это используется для возобновления исключения исключения:

capturedException.Throw();

Ответ 2

Нет, я не верю, что есть способ получить преимущества обоих. Однако бросание e.InnerException по-прежнему позволит вам получить исходную стеклу, потому что вы можете просто использовать e.InnerException.StackTrace для получения исходной трассировки стека. Итак, короче говоря, вы должны использовать опцию 1.

Ответ 3

Самый лучший вариант Вариант 3: вообще не использовать отражение, но вместо этого используйте Expression<T>.Compile().

Вместо этого:

static void CallMethodWithReflection(MethodInfo method)
{
    try
    {
        method.Invoke(null, new object[0]);
    }
    catch (TargetInvocationException exp)
    {
        throw exp.InnerException;
    }
}

Постарайтесь сделать это:

private static void CallMethodWithExpressionCompile(MethodInfo method)
{
    Expression.Lambda<Action>(Expression.Call(method)).Compile()();
}

Предостережение заключается в том, что вам нужно знать подпись метода, хотя вы можете написать код, который динамически создает выражение для соответствия одной из нескольких подписей.

Вы не всегда можете использовать эту технику, но когда вы это делаете, это лучший вариант. Для всех целей и целей это похоже на вызов любого другого делегата. Это также быстрее, чем отражение, если вы выполняете несколько вызовов (в этом случае компилируйте только один раз и сохраняйте дескриптор компилируемого делегата).

Ответ 4

У меня была аналогичная проблема и придумал следующее:

/// <summary>
/// Attempts to throw the inner exception of the TargetInvocationException
/// </summary>
/// <param name="ex"></param>
[DebuggerHidden]
private static void ThrowInnerException(TargetInvocationException ex)
{
    if (ex.InnerException == null) { throw new NullReferenceException("TargetInvocationException did not contain an InnerException", ex); }

    Exception exception = null;
    try
    {
        //Assume typed Exception has "new (String message, Exception innerException)" signature
        exception = (Exception) Activator.CreateInstance(ex.InnerException.GetType(), ex.InnerException.Message, ex.InnerException);
    }
    catch
    {
        //Constructor doesn't have the right constructor, eat the error and throw the inner exception below
    }

    if (exception == null ||
        exception.InnerException == null ||
        ex.InnerException.Message != exception.Message)
    {
        // Wasn't able to correctly create the new Exception.  Fall back to just throwing the inner exception
        throw ex.InnerException;
    }
    throw exception;
}

Пример его использования ниже:

try
{
    return typeof(MyType).GetMethod(methodName, BindingFlags.Public | BindingFlags.Static)
                                    .MakeGenericMethod(new[] { myType) })
                                    .Invoke(null, parameters);
}
catch (TargetInvocationException ex)
{
    ThrowInnerException(ex);
    throw new Exception("Throw InnerException didn't throw exception");
}