结构化异常处理

学习目标：

了解异常处理的基本知识

掌握如何抛出和捕获异常

理解嵌套try语句使用

了解掌握异常类

理解finally块

异常处理的基本知识

结构化异常处理测试特定的代码段，并在发生异常处理时改变错误情况或意外行为。

抛出和捕获异常

抛出和捕获异常是由try/catch/finally语句处理的，是异常处理的主要机制。

在C#处理异常时，需要在代码块中关注两个部分：一是可能导致异常的代码段（通常称为抛出异常），二是当执行过程中发生异常时将要执行的代码段（通常称为捕获异常）。

try/catch/finally语句块的基本语法如下：

            try

            {

                //可能产生异常的代码块

            }

            catch (Exception e)

            {

                //对异常进行处理的代码段

            }

            finally

            {

                //最终执行的代码块（无论是否产生异常，都会执行）

         }

如果没有错误发生，程序就会正常执行。如果发生异常，公共语言库将找到此代码最近一层的try块，而不用运行任何附加代码块。然控制传递到匹配的catch块2（如果有），并传递到关联的finally块。

如果发生异常，代码就会执行一定的操作，称为“抛出一个异常”。抛出一个异常就是实例化对象，并将其抛出，如下所示：

throw new Exception（）；

上面的语句实例化了Exception类的一个异常对象，在try中遇到throw语句，就会查找与这个try块对应的catch块。如果有多个对应的catch块，那么就会检查与catch块对应的异常类，确定正确的catch块。当抛出一个Exception对象时，程序会跳转到下面的catch块上：

catch(Exception e)

{

   //处理异常代码

}

下面举例说明如何抛出和捕获一个异常。在示例中，定义3个整形变量，当使用0作为除数时，将会发生异常，代码如下：  

class Program
    {
        static void Main(string[] args)
        {
            int a = 0;
            int b = 10;
            int c = 0;
            try
            {
                a = b / c;
            }
            catch (Exception e)
            {
                Console.WriteLine("发生异常：{0}", e.Message);
            }
            finally
            {
                Console.ReadLine();
            }
        }
    }

在上述代码中，当除数为0时抛出异常，语句块catch（Exception e）将成捕获该异常。

运行结果如下：

try-catch错误处理表达式允许将任何可能发生异常情形的程序代码放在try块进行监控，真正处理错误异常的程序代码则被放置在catch块中，一个try块可对应多个catch块，举例说明如何使用多个catch快捕捉多个异常，代码如下：

class myclass
    {
        static void ProcessString(string str)
        {
            if (str == null)
            {
                throw new ArgumentNullException();
            }
        }
        static void Main(string[] args)
        {
            Console.WriteLine("输出结果为：");
            try
            {
                string str = null;
                ProcessString(str);
            }
            catch (ArgumentNullException e)
            {
                Console.WriteLine("第一个异常：{0}", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("第二个异常：{0}", e.Message);
            }
            finally
            {
                Console.ReadLine();
            }
        }

本例中通过catch语句块进行捕获异常，分别是ArgumentNullException异常和Exception异常。

运行结果为：

注意：如果没有catch语句块，程序会异常终止，使用不带参数的catch子句4，则可以捕获任何异常类型。

嵌套try语句：try语句允许嵌套，语句如下：

         try
          {
       　　　 //代码块1 
　　 　　　　　try
             {
                //代码块2
             }
             catch 
             {
                //代码块3
              }
              finally
              {
               // 最终代码
　　　　　　　　}
              //代码块4
           }
       catch 
　　　 　{
　　　　　　//异常处理
        }
　　    finally
       {
          // 最终代码
　　  　}

如果异常在外层的try块中抛出，异常由外层的catch块捕获，并执行外层的finally块。如果异常在内层的try块（代码块2）中抛出，且有一个合适的内层catch块处理该异常，执行内层的finally块之后，继续执行外层的try块（标记为4代码块）。

主要的异常类

System.Exception类是其他异类的基类。System.Exception表示应用程序执行期间发生的错误。大多数异常对象都是Exception的某个派生类的实例。不过，任何从Object类派生的对象都可以作为异常引发。

Exception 类成员的使用：

class exception
    {
        static void Main(string[] args)
        {
            try
            {
                Exception myEx = new Exception("原始异常");
                throw myEx;
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常类型：{0}", ex.GetType().ToString());//GetType方法获取当前实例的运行时类型，ToString方法用于创建并返回当前异常的字符串表示形式

                Console.WriteLine("异常信息：{0}", ex.Message);//Message获取描述当前异常的消息

                Console.WriteLine("堆栈跟踪：{0}", ex.StackTrace);//StackTrace用于获取当前异常发生时调用堆栈上方法的信息，有助于跟踪抛出异常的方法     

                Console.WriteLine("应用程序名称：{0}", ex.Source);//Source用于获取或设置导致错误的应用程序或对象的名称

            }
            finally
            {
                Console.ReadLine();
            }
        }
}

运行程序，结果输出如下：

抛出预定义异常：也就是抛出内部异常类的对象

自定义异常：自定义的异常在异类中扮演一个非常重要的角色，建立一个自定义异常类，继承于ApplictionException类，

//自定义异常类

class numException : ApplicationException
    {
        public void printError()
        {
            Console.WriteLine("输入的数小于1或者大于9，请重新输入!!");
        }
    }
    class CustomException
    {
        static void Main(string[] args)
        {
            string num;
            do 
            {
                Console.WriteLine("请输入一个数，输入'exit'退出程序!");
                num=Console.ReadLine();
                System.Text.RegularExpressions.Regex rx=new System.Text.RegularExpressions.Regex (@"^[1-
            9]$");//使用正则表达式判断
                try
                {
                    if (rx.IsMatch(num))
                    {
                        for(int i=0;i<10;i++)
                        {
                            Console.WriteLine("{0}*{1}={2}",i,num,i*Convert.ToInt32(num));
                        }
                    }
                   else 
                    {
                        //抛出异常错误
                        throw new numException ();
                    }
                    //捕获异常
                }
                catch (numException ex)
                {
                    ex.printError();
                    Console.WriteLine("异常类型：{0}"ex.GetType().ToString());
                }
            }while (!num.ToLower().Equals("exit"));
        }
    }

输出结果：

finally块

发生异常时，执行将终止，并且交给最近的异常处理程序。Finally块可以确保发生异常时执行所有的清理工作

finally块工作方式：

class myFinally
    {
        static void Main(string[] args)
        {
            int[] array1 ={ 0, 0 };
            int[] array2 ={ 0, 0 };
            try
            {
                Array.Copy(array1, array2,-1);
            }
            catch (ArgumentOutOfRangeException e)
            {
                Console.WriteLine("Error:{0}",e);
            }
            finally 
            {
                Console.WriteLine("总是执行finally块");
            }
            Console.ReadLine();
        }
    }

 运行程序，不管是否发生异常，finally块都会执行，结果如下：

注意：finally块必须和try/catch快一起使用，不管是否发生异常，finally块都将保证运行