解析Exception和C#處理Exception的常用方法總結

   在.NET中，異常是指成員沒有完成它的名稱宣稱可以完成的行動。在異常的機制中，異常和某件事情的發生頻率無關。

    異常處理四要素包括：一個表示異常詳細信息的類類型；一個向調用者引發異常類實例的成員；調用者的一段調用異常成員的代碼塊；調用者的一段處理將要發生異常的代碼塊。異常類類型包括：基類：System.Exception；系統級異常：System.SystemException；應用程序級異常：System.ApplicationException。

   (一).在.NET中有如下的異常類：

     (1).由System.SystemException派生的異常類型：

    (2).由System.ArgumentException派生的異常類型：

   (3).由System.ArithmeticException派生的異常類型：

   (4).由System.IOException派生的異常類型：

   (5).其他常用異常類型：     

(二)..NET的異常處理方式：

      發生異常時，系統將搜索可以處理該異常的最近的 catch 子句（根據該異常的運行時類型來確定）。首先，搜索當前的方法以查找一個詞法上包含著它的 try 語句，并按順序考察與該 try 語句相關聯的各個 catch 子句。如果上述操作失敗，則在調用了當前方法的方法中，搜索在詞法上包含著當前方法調用代碼位置的 try 語句。此搜索將一直進行下去，直到找到可以處理當前異常的 catch 子句（該子句指定一個異常類，它與當前引發該異常的運行時類型屬于同一個類或是該運行時類型所屬類的一個基類）。注意，沒有指定異常類的 catch 子句可以處理任何異常。

   找到匹配的 catch 子句后，系統將把控制轉移到該 catch 子句的第一條語句。在 catch 子句的執行開始前，系統將首先按順序執行嵌套在捕捉到該異常的 try 語句里面的所有 try 語句所對應的全部 finally 子句。

      (1).try塊：包含的代碼通常需要執行一些通用的資源清理操作，或者需要從異常中恢復，或者兩者都需要。try塊還可以包含也許會拋出異常的代碼。

      (2).catch塊：包含的是響應一個異常需要執行的代碼。如果沒有任何捕捉類型與拋出的異常匹配，CLR會去調用棧的更高一層搜索一個與異常匹配的捕捉類型。

      (3).finally塊：包含的代碼是保證會執行的代碼。finally塊所有代碼執行完畢后，線程退出finally塊，執行緊跟在finally塊之后的語句。

(三).Exception的常用屬性的源碼解析：

     (1).Message：包含輔助性文字說明，指出拋出異常的原因。

public virtual String Message {
               get {
                if (_message == null) {
                    if (_className==null) { 
                        _className = GetClassName();
                    } 
                    return Environment.GetRuntimeResourceString("Exception_WasThrown", _className); 

                } else { 
                    return _message;
                }
            }
        }

(2).Data：對一個“鍵/值對”集合的引用。

public virtual IDictionary Data { 
            [System.Security.SecuritySafeCritical]  // auto-generated 
            get {
                if (_data == null) 
                    if (IsImmutableAgileException(this))
                        _data = new EmptyReadOnlyDictionaryInternal();
                    else
                        _data = new ListDictionaryInternal(); 

                return _data; 
            } 
        }

(3).Source:包含生成異常的程序集名稱。

public virtual String Source {
            #if FEATURE_CORECLR 
            [System.Security.SecurityCritical] // auto-generated
            #endif 
            get { 
                if (_source == null)
                { 
                    StackTrace st = new StackTrace(this,true);
                    if (st.FrameCount>0)
                    {
                        StackFrame sf = st.GetFrame(0); 
                        MethodBase method = sf.GetMethod();
 
                        Module module = method.Module; 

                        RuntimeModule rtModule = module as RuntimeModule; 

                        if (rtModule == null)
                        {
                            System.Reflection.Emit.ModuleBuilder moduleBuilder = module as System.Reflection.Emit.ModuleBuilder; 
                            if (moduleBuilder != null)
                                rtModule = moduleBuilder.InternalModule; 
                            else 
                                throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeReflectionObject"));
                        } 

                        _source = rtModule.GetRuntimeAssembly().GetSimpleName();
                    }
                } 

                return _source; 
            } 
            #if FEATURE_CORECLR
            [System.Security.SecurityCritical] // auto-generated 
            #endif
            set { _source = value; }
        }

 (四).異常處理的常用方法：

    (1).提取異常及其內部異常堆棧跟蹤

/// <summary>
        /// 提取異常及其內部異常堆棧跟蹤
        /// </summary>
        /// <param name="exception">提取的例外</param>
        /// <param name="lastStackTrace">最后提取的堆棧跟蹤（對于遞歸）， String.Empty or null</param>
        /// <param name="exCount">提取的堆棧數（對于遞歸）</param>
        /// <returns>Syste.String</returns>
        public static string ExtractAllStackTrace(this Exception exception, string lastStackTrace = null, int exCount = 1)
        {
            var ex = exception;
            const string entryFormat = "#{0}: {1}\r\n{2}";
            //修復最后一個堆棧跟蹤參數
            lastStackTrace = lastStackTrace ?? string.Empty;
            //添加異常的堆棧跟蹤
            lastStackTrace += string.Format(entryFormat, exCount, ex.Message, ex.StackTrace);
            if (exception.Data.Count > 0)
            {
                lastStackTrace += "\r\n    Data: ";
                foreach (var item in exception.Data)
                {
                    var entry = (DictionaryEntry)item;
                    lastStackTrace += string.Format("\r\n\t{0}: {1}", entry.Key, exception.Data[entry.Key]);
                }
            }
            //遞歸添加內部異常
            if ((ex = ex.InnerException) != null)
                return ex.ExtractAllStackTrace(string.Format("{0}\r\n\r\n", lastStackTrace), ++exCount);
            return lastStackTrace;
        }

（2）.異常處理常用方法：

/// <summary>
        /// 檢查字符串是空的或空的，并拋出一個異常
        /// </summary>
        /// <param name="val">值測試</param>
        /// <param name="paramName">參數檢查名稱</param>
        public static void CheckNullOrEmpty(string val, string paramName)
        {
            if (string.IsNullOrEmpty(val))
                throw new ArgumentNullException(paramName, "Value can't be null or empty");
        }
        
         /// <summary>
        /// 請檢查參數1不同于參數2
        /// </summary>
        /// <param name="param1">值1測試</param>
        /// <param name="param1Name">name of value 1</param>
        /// <param name="param2">value 2 to test</param>
        /// <param name="param2Name">name of vlaue 2</param>
        public static void CheckDifferentsParams(object param1, string param1Name, object param2, string param2Name)
        {
            if (param1 == param2) {
                throw new ArgumentException(param1Name + " can't be the same as " + param2Name,
                    param1Name + " and " + param2Name);
            }
        }

        /// <summary>
        /// 檢查一個整數值是正的（0或更大）
        /// </summary>
        /// <param name="val">整數測試</param>
        public static void PositiveValue(int val)
        {
            if (val < 0)
                throw new ArgumentException("The value must be greater than or equal to 0.");
        }

  異常處理器(程序)：對于程序中出現的異常,在C#中是使用一種被稱為“異常處理器(程序)”的錯誤捕獲機制來進行處理的, 你可以認為異常處理器(程序)就是發生錯誤時,能夠接受并處理錯誤的接受者和處理。