• Related
• Related

我想动态调用一个 MethodInfo对象并让从其内部抛出的任何异常向外传递，就好像它被正常调用一样。

看来我有两个选择。它们概述如下。

选项 1 维护 MyStaticFunction 抛出的异常类型，但是 StackTrace因为 throw 被毁了.

选项 2 维护 StackTrace的异常，但异常的类型始终是 TargetInvocationException .我可以拉出 InnerException及其类型，但这意味着我不能这样写，例如:

try { DoDynamicCall(); }
catch (MySpecialException e) { /* special handling */ }

选项 1:

void DoDynamicCall()
{
    MethodInfo method = /*referencing MyClass method void MyStaticFunction(int x)*/;
    try
    {
        method.Invoke(null, new object[] { 5 });
    }
    catch (TargetInvocationException e)
    {
        throw e.InnerException;
    }
}

选项 2:

void DoDynamicCall()
{
    MethodInfo method = /*referencing MyClass method void MyStaticFunction(int x)*/;
    method.Invoke(null, new object[] { 5 });
}

我真正想要的是给DoDynamicCall的来电者接收异常，就好像他们调用了这个:

void DoDynamicCall()
{
    MyClass.MyStaticFunction(5);
}

有没有办法同时获得选项 1 和选项 2 的好处？

编辑:

我希望拥有的选项(当场发明了特殊的新 C# 关键字 rethrow):

void DoDynamicCall()
{
    MethodInfo method = /*referencing MyClass method void MyStaticFunction(int x)*/;
    try
    {
        method.Invoke(null, new object[] { 5 });
    }
    catch (TargetInvocationException e)
    {
        //Magic "rethrow" keyword passes this exception
        //onward unchanged, rather than "throw" which
        //modifies the StackTrace, among other things
        rethrow e.InnerException;
    }
}

这也将消除对这个怪人的需要，因为你可以使用 rethrow e;相反:

try { ... }
catch (Exception e)
{
    if (...)
        throw;
}

一般来说，这将是一种解耦 throw; 的方法从要求“我必须直接在一个 catch block 中。”

最佳答案

这是我想出的解决方案。它完成了工作。我仍然对其他答案感兴趣，因为可能会有更简单或更清晰的答案。

• 当你想要throw;的功能但是你想要传递的异常不是当前catch block 的异常时，使用throw功能。重新抛出(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(); }
    }
}

更新

在 .NET 4.5 中有新的 System.Runtime.ExceptionServices.ExceptionDispatchInfo class .这可用于捕获异常:

var capturedException = ExceptionDispatchInfo.Capture(e);

然后这用于恢复抛出异常:

capturedException.Throw();

关于c# - 保留动态调用方法的异常，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15668334/