C# 异常处理（一）

　　问题一：try-catch-finally  中有return的情况，会如何执行

             很多人都会纠结这么一个问题try-catch-finally中有return的情况，我自己总结如下：

            1.1 如果是值类型的话

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace 含有return的测试
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             int j = Test();
13             Console.WriteLine(j);
14            
15         }
16         /// <summary>
17         /// 这个是测试return里面的是值类型就不会对他们有影响呢 
18         /// </summary>
19         /// <returns></returns>
20         static int Test()
21         {
22              int i = 0;
23 
24             try
25             {
26                
27                 return i; //为什么这里要加个return呢
28             }
29             catch (Exception)
30             {
31 
32                 i++;
33                 return i;
34 
35             }
36             finally
37             {
38                 i = i + 2;
39             }
40         
41         }
42         
43 
44     }
45 }

 

　　  通过上面的代码可以看出，这里的finally执行了之后，对return返回没有影响 return返回结果还是0;

　　  1.2  返回值是引用类型

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace 引用类型测试
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             List<string> strList = Test();
13              foreach (var i in strList)
14             {
15                 Console.WriteLine(i);
16             }
17             Console.ReadKey();
18         }
19         private static List<string> Test()
20         {
21             List<string> strList = new List<string>();
22             strList.Add("aa");
23             strList.Add("bb");
24             strList.Add("cc");
25             try
26             {
27                 //这里没有发生异常的 
28                 strList.Add("trytry");
29                 return strList;
30             }
31             catch (Exception ex)
32             {
33                 strList.Add("zzz");
34                 return strList;
35             }
36             finally
37             {
38                 strList.Add("yyy");
39             }
40         }  
41 
42     }
43 }

输出结果如下：

通过以上两个例子可以总结:  如果是值类型的话，finally里面的改变不会对try或者catch中的return返回值造成影响。

                                              如果是引用类型的话，finally里面的改变会对try或者catch中的return返回值造成影响(除了String外)。

                                              造成这个结果的主要原因就是return返回的是栈中的地址。

　  问题二:多个Try catch finally的执行顺序。

         try这个执行顺序不说了。

         catch块：如果Try块中的代码没有抛出异常的话呢，CLR永远都不会执行它的任何Catch块

         如果是不会报异常的话，线程就会跳过catch块，直接执行finally块（如果有的话）。

         但是如果try块里面报了异常的话呢。并且Catch也能捕捉到这个异常（第一层Catch就可以捕捉到）。那就是try catch finally的顺序执行。

         假设第一层Catch没有匹配到，就会继续往上面的抛，直到Catch可以匹配到。如果没有匹配到Catch就直接报异常了，程序崩了(如果没有捕捉到异常的话呢，finally的语句是不会执行的。如果有finally的话，最后面会去执行finally）。

         如果catch第一层没有捕捉到，在第二层也没有捕捉到，在第三层的Catch里面捕捉到这个异常的话呢，会在进入catch之前先之前第一层的finally（如果有），第二层finally执行完了，才去第三层执行对应的catch里面的内容：如下面代码所示：

  
 static void MethodFour()
        {
            try
            {
                throw new NotImplementedException();
            }
            catch(DivideByZeroException ex)
            {

            }
            finally
            {
                Console.WriteLine("最里面的 finally");
            }
        }

         上面这个方法是不会匹配到异常，异常会往上面抛（它的调用如下）

    try
            {
                MethodFour();
                //这里输出的顺序是先finally，再Exception。
            }
            catch(Exception ex)
            {
                //异常会往上抛,在它匹配到这个异常的时候.
                Console.WriteLine($"Exception");
            }
            finally
            {
                Console.WriteLine("最外面的 Finally");
            }

        具体结果如何，大家可以动手试试。

      问题三：很多人说Catch要指定先具体的异常类型，最后再写一个Exception。     

         try块：一般是可能报异常的。每一个try至少有一个catch块或finally块。

         catch块：包含的是响应异常需要执行的代码。如果一个try块里面没有造成异常，CLR永远不会执行它的任何catch块。线程将跳过所有catch块，直接执行finally块（如果有的话）。

         catch关键字后的圆括号中的表达式称为捕捉类型。C#要求捕捉类型必须是System.Exception或者它的派生类型。

          有了这两个基础之后，再解释问题一，CLR是自上而下搜索匹配catch块，所以应该将较具体的异常放在顶部。也就是说首先要出现的是派生度最大的异常类型，接着是它们的基类型（如果有的话），最后是System.Exception（或者是没有指定任何捕捉类型的catch块）。

          那么问题又来了，很多时候，我们是直接一个try{ ...}catch(excepiton ex){ ... } ，和我们上面说的做法（写到具体的异常类型）有多大区别呢。

         直接上例子：

     static void MethodOne()
        {
            try
            {
                int i = 0;
                int j = 10 / i;
            }
            catch(FormatException ex)
            {
                //假设这里多一层比较，再匹配到
            }
            catch (DuplicateWaitObjectException ex)
            {
                //再多一层比较
            }
            catch(DivideByZeroException ex)
            {
               // Console.WriteLine("DivideByZeroException异常");
            }
            catch(Exception ex)
            {
                Console.WriteLine("Exception ONE");
            }
        }

  static void MethodTwo()
        {
            try
            {
                int i = 0;
                int j = 10 / i;
            }
            catch (Exception ex)
            {
              //  Console.WriteLine("Exception TWO");
            }
        }

      上面的例子，跑出来的结果说明（大家动手跑一下），methodone(匹配到具体异常的）要比methondtwo(直接exception）要高效。

　问题四：Throw和Throw ex区别

      每次看到别人写的代码有时候Throw; 有时候又Throw ex；总是充满好奇，他们为什么要这么写，这样写有啥区别呢。下面我们一起来看看究竟。

      1、先说Throw ex会重置异常，异常堆栈信息会重新抛出，这样就会影响我们根据异常信息来定位问题。

      2、Throw 会传递异常，不会重置异常。

      static void TestMethod()
        {
            try
            {
                Console.WriteLine($"ThreadId{Thread.CurrentThread.ManagedThreadId}");
                TestThrow();
            }
            catch (Exception ex)
            {
                Console.WriteLine("除以零报异常了");
                //throw ex;//把异常信息向上抛了。
                throw ex;
            }
            
        }

        static void TestThrow()
        {
            var t = 0;
            var res = 10 / t;
        }

　　问题五：对于try catch finally对性能影响一说

　　

  //当异常被重置的话呢。
            try
            {

            }
            catch(FormatException ex)
            {
                //这里写一个日志。logHelp.write(ex)
                throw new Exception("格式化异常");
            }
            catch(DivideByZeroException ex)
            {
                //这里写一个日志。logHelp.write(ex)
                throw new Exception("尝试除以零");
            }
            catch(IndexOutOfRangeException ex)
            {
                //这里写一个日志。logHelp.write(ex)
                throw new Exception("索引溢出");
            }
            catch(Exception ex)
            {
                //这里写一个日志。logHelp.write(ex)
                throw new Exception("其他异常");
            }
            finally
            {
                //资源清理
            }

　　从上面这段代码，可以看到try catch finally给我们的感觉就是代码结构清晰，分门别类。

 　   异常的处理好处有如下（个人觉得）

　　1、代码可读性很好，正常的逻辑和异常处理，资源清理都分开。

　　2、系统可靠性提升了。

　　3、链式调用方法可以很轻松的实现了。

       关于性能这一说法：

       一旦异常被抛出去的话，函数也会跟着return,而程序在执行时候，需要处理函数栈的上下文，如果函数栈比较深的话，性能就更加受影响了。从另外一方面来说，如果你的程序报异常了，就应该要停止执行了。程序本来就应该在没有异常的情况下执行的(所以你大部分情况下，程序是不会抛出异常的，对性能的影响也就不那么大了）。

 

      

 

 

         

 

 

转载于:https://www.cnblogs.com/gdouzz/p/4763224.html