在 .NET 异常中保留原始 StackTrace/LineNumbers

Question

了解throw ex和throw的区别，为什么在这个例子中保留了原始的StackTrace：

    static void Main(string[] args)
    {
        try
        {
            LongFaultyMethod();
        }
        catch (System.Exception ex)
        {
            Console.WriteLine(ex.StackTrace);
        }
    }

    static void LongFaultyMethod()
    {
        try
        {
            int x = 20;
            SomethingThatThrowsException(x);
        }
        catch (Exception)
        {
            throw;
        }
    }

    static void SomethingThatThrowsException(int x)
    {
        int y = x / (x - x);
    }

但不是在这个：

    static void Main(string[] args)
    {
        try
        {
            LongFaultyMethod();
        }
        catch (System.Exception ex)
        {
            Console.WriteLine(ex.StackTrace);
        }
    }

    static void LongFaultyMethod()
    {
        try
        {
            int x = 20;
            int y = x / (x - 20);
        }
        catch (Exception)
        {
            throw;
        }
    }

第二种情况是产生与 throw ex 相同的输出吗？

在这两种情况下，人们都希望看到初始化 y 的行号。

Answer 1

我不确定此限制是否在 C# 语言、CLI 或 Microsoft 实现中，但您的第二个示例是需要显式调用 Exception.InternalPreserveStackTrace 的情况，如以下帖子中所述.由于这个方法是internal，所以一般要通过反射调用。通过为调用创建Action<Exception> 几乎可以完全缓解其中涉及的性能问题，如本答案末尾所示。

参考：Rethrowing exceptions and preserving the full call stack trace

编辑：在重新检查 ECMA-335 Partition I §12.4.2（异常处理）和 Partition III §4.24（重新抛出）后，我现在认为您看到的行为是语义错误CLR（微软的 CLI 实现）。对该行为的唯一具体引用是“A rethrow 不会更改对象中的堆栈跟踪”。在此处描述的情况下，重新抛出实际上改变了堆栈跟踪，使PreserveStackTrace hack 成为已知 CLR 缺陷的解决方法。

static void LongFaultyMethod() 
{ 
    try 
    { 
        int x = 20; 
        int y = x / (x - 20); 
    } 
    catch (Exception ex) 
    { 
        PreserveStackTrace(ex); // <-- add this line
        throw; 
    } 
} 

PreserveStackTrace 这是对该博客条目的优化：

private static readonly Action<Exception> _internalPreserveStackTrace =
    (Action<Exception>)Delegate.CreateDelegate(
        typeof(Action<Exception>),
        typeof(Exception).GetMethod(
            "InternalPreserveStackTrace",
            BindingFlags.Instance | BindingFlags.NonPublic));

public static void PreserveStackTrace(Exception e)
{
    _internalPreserveStackTrace(e);
}

Answer 2

因为在第二个示例中，您正在从同一方法重新抛出异常。首先它是从不同的方法抛出的，这就是为什么。在一个方法范围内，堆栈跟踪只能是一个。

按照以下方式操作，最好的方法是始终将异常包装在新异常中，以便您看到异常深度。

"如果重新抛出已在 相同的方法（异常堆栈跟踪 只有一个行号信息 每个方法，你永远不会看到堆栈跟踪 在方法 A 中的第 2 行 抛出异常，然后在同一个 方法A，从行重新抛出 数字 17，它只包含最后一个 异常所在的行号 重新抛出”

try        
{            
   int x = 20;            
   int y = x / (x - 20);        
}        
catch (Exception ex)        
{            
   // do something here.. like log or something
   throw new Exception("Internal Exception", ex);        
}

我对这么多 cmets 没有阅读我的评论感到惊讶！我在评论中写道，您可能应该安全地记录这个，有多种原因，如果顶级代码吃掉异常并且您不知道抛出了哪个和哪里的异常，日志记录可以帮助您交叉异常！ ！

如果您不需要记录，则不要捕获异常。