唯一標識.NET異常

Question

我期待通過對異常進行分組來改進我們的.NET應用程序日誌記錄。理想情況下，我們會根據代碼中出現的位置以及它們是哪種類型的異常進行分組。所以基本上，我們最終會得到每個單一異常（具有不同日期，服務器變量等）的事件列表。

例如，如果我在我的註冊使用頁面上有一個方法，它引發了一個空引用異常5次，我會列出該異常只有一次，計數爲5次。另一個頁面上引發的另一個空引用異常將單獨列出。

是否有可能使用堆棧跟蹤來可靠地識別異常或是否有其他我已經錯過的東西？

Answer 1

如果一個異常被捕獲然後重新拋出，那麼它的堆棧跟蹤就會出現，就好像在重新拋出的地方發生了異常，而不是原來的地方。希望在你的代碼中沒有太多的東西在進行。如果不是，那麼堆棧跟蹤應該足以區分異常位置。

另一個問題是堆棧跟蹤是否相同，以便它們看起來不是兩個不同的異常，當它們確實相同時。這也不應該成爲一個問題，因爲根據我的經驗，堆棧軌跡是相同的。 （異常對象上的ToString（）結果不會，一般是相同的。）

修訂

已經有關於什麼情況是，該Exception.StackTrace將被損壞了一些討論。基本規則是，任何時候

throw *expression*; 

被執行，那麼Exception對象*expression*標識將其StackTrace屬性設置。如果省略了*expression*

throw; 

那麼StackTrace將不會生效。

我找不到這兩種形式的術語，所以我會分別稱它們爲「顯式」和「隱式」。請注意，*expression*解析爲的異常對象是new還是已存在的對象都沒有關係。

這裏是一個程序來說明這個問題：

using System; 
namespace FunWithExceptions 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      try { Replace(); } 
      catch (InvalidOperationException ex) { DisplayResult("Replace resulted in", ex); } 

      try { RethrowExplicit(); } 
      catch (InvalidOperationException ex) { DisplayResult("RethrowExplicit resulted in", ex); } 

      try { RethrowImplicit(); } 
      catch (InvalidOperationException ex) { DisplayResult("RethrowImplicit resulted in", ex); } 

      InvalidOperationException myException = new InvalidOperationException(); 
      DisplayResult("myException starts with", myException); 
      try { throw myException; } 
      catch (InvalidOperationException) { } 
      DisplayResult("myException changes to", myException); 
      Console.ReadLine(); 
     } 

     static void ThrowAnException() 
     { throw new InvalidOperationException("You messed up!"); } 

     static void Replace() 
     { 
      try { ThrowAnException(); } 
      catch (InvalidOperationException ex) 
      { 
       DisplayResult("Replace caught", ex); 
       throw new InvalidOperationException("Another mistake."); 
      } 
     } 

     static void RethrowExplicit() 
     { 
      try { ThrowAnException(); } 
      catch (InvalidOperationException ex) 
      { 
       DisplayResult("RethrowExplicit caught", ex); 
       throw ex; 
      } 
     } 

     static void RethrowImplicit() 
     { 
      try { ThrowAnException(); } 
      catch (InvalidOperationException ex) 
      { 
       DisplayResult("RethrowImplicit caught", ex); 
       throw; 
      } 
     } 

     static void DisplayResult(string context, Exception ex) 
     { 
      Console.WriteLine("{0} exception thrown at {1}", context, FirstMethodName(ex.StackTrace)); 
     } 

     private const string methodNamePrefix = " at FunWithExceptions.Program."; 

     private static object FirstMethodName(string stackTrace) 
     { 
      stackTrace = stackTrace ?? string.Empty; 
      if (stackTrace.StartsWith(methodNamePrefix)) 
       stackTrace = stackTrace.Substring(methodNamePrefix.Length); 
      int methodNameEndIndex = stackTrace.IndexOf(')'); 
      if (methodNameEndIndex != -1) 
       stackTrace = stackTrace.Substring(0, methodNameEndIndex + 1); 
      if (stackTrace.Length > 0) 
       return stackTrace; 
      else 
       return "--empty--"; 
     } 
    } 
} 

此程序將導致下面的輸出：

更換）在ThrowAnException（拋出捕獲的異常

更換導致異常扔在Replace（）

RethrowExplicit捕獲的異常拋出ThrowAnException（）

RethrowExplicit導致（）在RethrowExplicit拋出的異常

在ThrowAnException（）拋出RethrowImplicit捕獲的異常

RethrowImplicit導致（）在ThrowAnException拋出的異常

myException與拋出的異常啓動at --empty--

myException更改爲在Main（String [] args）引發的異常

第六行是有趣的一個。

在那裏，我現在已經徹底擊敗了這一點。 :-)

Answer 2

只要你不吞嚥異常，然後拋出一個新的異常（如下面的壞例子），你應該沒問題。

try 
{ 
    ... your code 
} 
catch (ExceptionA exA) 
{ 
    ... some error handling 
    throw new ExceptionZ(); 
} 
catch (ExceptionB exB) 
{ 
    ... some error handling 
    throw new ExceptionZ(); 
} 

這段代碼在這個實例中是壞的，因爲拋出一個異常將從原始異常中取代堆棧跟蹤。無論如何，這並不是一個好習慣，但在這種情況下，它會阻止你找到並記錄你的例外。

Answer 3

在您的示例中（並且在大多數情況下，確實如此），根據null值的不同，我將有兩個不同的自定義異常類型被拋出。捕獲這些異常的代碼可以記錄必要的數據。

Answer 4

好吧，所以你基本上想要可靠地識別例外PLUS位置的異常。 堆棧跟蹤對我來說似乎很好。 但是，您也可以根據使用位置信息的識別方法名

System.Reflection.MethodBase.GetCurrentMethod() 

可以得到從基地外，所有的異常類型，將在構造函數中調用GetCurrentMethod（），並通過只讀屬性暴露的方法名稱，所以你知道在哪裏想要捕捉異常的地方創建異常的地方。

例子：

public class BaseException : ApplicationException { 
    public BaseException() { 
     _originalMethod = System.Reflection.MethodBase.GetCurrentMethod().Name; 
    } 
    private string _originalMethod; 
    public string OriginalMethod { get { return _originalMethod; } } 
} 

//now, create tons of custom exceptions: 
public class MyException1 : BaseException { 
    public MyException1() 
     : base() { 
    } 
} 
//create more custom exceptions... 
public class MyExceptionNNN : BaseException { 
    public MyExceptionNNN() 
     : base() { 
    } 
}