C#图解教程 第二十二章 异常

异常

什么是异常


异常是程序中的运行时错误,它违反了系统约束或应用程序约束,或出现了在正常操作时未预料的情形。例如,程序试图除以0或试图写一个只读文件。当这些发生时,系统捕获这个错误并抛出(raise)一个异常。
如果程序没有提供处理该异常的代码,系统会挂起这个程序。例如,下面的代码在试图用0除一个数时抛出一个异常:

class Program
{
    static void Main()
    {
        int x=10,y=0;
        x/=y;        //用0除以一个数时抛出一个异常
    }
}

当这段代码运行时,系统显示下面的错误信息:

try语句


try语句用来指明为避免出现异常而被保护的代码段,并在发生异常时提供代码处理异常。try语句由3个部分组成,如下图所示。

  • try 块包含为避免出现异常而被保护的代码
  • catch 子句部分含有一个或多个catch子句。这些是处理异常的代码段,它们也称为是异常处理程序
  • finally 块含有在所有情况下都要被执行的代码,无论有没有异常发生

处理异常

前面的示例显示了除以0会导致一个异常。可以修改此程序,把那段代码放在一个try块中,并提供一个简单的catch子句,以处理该异常。当异常发生时,它被捕获并在catch块中处理。

static void Main()
{
    int x = 10;
    try
    {
        int y=0;
        x/=y; //抛出异常
    }
    catch
    {
        …//异常处理代码
        Console.WriteLine("Handling all exceptions - keep on Running");
    }
}

这段代码产生以下消息。注意,除了输出消息,没有异常已经发生的迹象。

异常类


有许多不同类型的异常可以在程序中发生。BCL定义了许多类,每一个类代表一个指定的异常类型。当一个异常发生时,CLR:

  • 创建该类型的异常对象
  • 寻找适当的catch子句以处理它

所有异常类都从根本上派生自System.Exception类。异常继承层次的一个部分如下图所示。

异常对象含有只读属性,带有导致该异常的信息。这些属性的其中一些如下表所示。

catch 子句


catch子句处理异常。它有3种形式,允许不同级別的处理。这些形式如下图所示。

一般catch子句能接受任何异常,但不能确定引发异常的类型。这只允许对任何可能发生的异常的普通处理和清理。
特定catch子句形式把一个异常类的名称作为参数。它匹配该指定类或派生自它的异常类的异常。
带对象的特定catch子句提供关于异常的最多信息。它匹配该指定类的异常,或派生自它的异常类的异常。它还给出一个异常实例(称为异常变量),是一个对CLR创建的异常对象的引用。可以在catch子句块内部访问异常变量的属性,以获取关于引起的异常的详细信息。
例如,下面的代码处理IndexOutOfRangeException类型的异常。当异常发生时,一个实际异常对象的引用被参数名e传入代码。那3个WriteLine语句中,每个都从异常对象中读取一个字符串字段。

catch(IndexOutOfRangeException e)
{
    Console.WriteLine("Message: {0}",e.Message);
    Console.WriteLine("Source:  {0}",e.Source);
    Console.WriteLine("Stack:   {0}",e.StackTrace);
}

使用特定catch子句的示例


回到除以0的示例,下面的代码把前面的catch子句修改为指定处理DivideByZeroException类的异常。在前面的示例中,catch子句会处理所在try块中引起的任何异常,而这个示例将只处理DivideByZeroException类的异常。

int x=10;
try
{
    int y=0;
    x/=y;
}
catch(DivideByZeroException)
{
    …
    Console.WriteLine("Handling an exception.");
}

可以进一步修改catch子句以使用一个异常变量。这允许在catch块内部访问异常对象。

int x=10;
try
{
    int y=0;
    x/=y;
}
catch(DivideByZeroException e)
{
    Console.WriteLine("Message: {0}",e.Message);
    Console.WriteLine("Source:  {0}",e.Source);
    Console.WriteLine("Stack:   {0}",e.StackTrace);
}

在笔者的电脑上,这段代码会产生以下输出。对于读者的机器,第三行和第四行的代码路径可能不同,这要与你的项目位置和解决方案目录匹配。

catch子句段


catch子句的目的是允许你以一种优雅的方式处理异常。如果你的catch子句接受一个参数,那么系统会把这个异常变量设置为异常对象,这样你就可以检査并确定异常的原因。如果异常是前一个异常引起的,你可以通过异常变量的InnerException属性来获得对前一个异常对象的引用。catch子句段可以包含多个catch子句。下图显示了catch子句段。
当异常发生时,系统按顺序搜索catch子句的列表,第一个匹配该异常对象类型的catch子句被执行。因此,catch子句的排序有两个重要的规则。具体如下。

  • 特定catch子句必须以一种顺序排列,最明确的异常类型第一,直到最普通的类型。例如,如果声明了一个派生自NullReferenceException的异常类,那么派生异常类型的catch子句应该被列在NullReferenceException的catch子句之前
  • 如果有一个一般catch子句,它必须是最后一个,并且在所有特定catch子句之后。不鼓励使用一般catch子句.因为它允许程序继续执行隐藏错误,让程序处于一种未知的状态。应尽可能使用特定catch子句

finally块


如果程序的控制流进人了一个带finally块的try语句,那么finally始终会被执行。下图阐明了它的控制流。

  • 如果在try块内部没有异常发生,那么在try块的结尾,控制流跳过任何catch子句并到finally块
  • 如果在try块内部发生了异常,那么在catch子句段中无论哪一个适当的catch子句被执行,接着就是finally块的执行


即使try块中有return语句或在catch块中抛出一个异常,finally块也总是会在返回到调用代码之前执行。例如,在下面的代码中,在try块的中间有一条return语句,它在某条件下被执行。
这不会使它绕过finally语句。

try
{
    if(inVal<10)
    {
        Console.Write("First Branch - ");
        return;
    }
    else
    {
        Console.Write("Second Branch - ");
    }
}
finally
{
    Console.WriteLine("In finally statement");
}

这段代码在inVal值为5时产生以下输出:

为异常寻找处理程序


当程序产生一个异常时,系统查看该程序是否为它提供了一个处理代码。下图阐明了这个控制流。

  • 如果在try块内发生了异常,系统会査看是否有任何一个catch子句能处理该异常
  • 如果找到了适当的catch子句,以下3项中的1项会发生
    • 该catch子句被执行
    • 如果有finally块,那么它被执行
    • 执行在try语句的尾部继续(也就是说,在finally块之后,或如果没有finally块,就在最后一个catch子句之后)

更进一步搜索


如果异常在一个没有被try语句保护的代码段中产生,或如果try语句没有匹配的异常处理程序,系统将不得不更进一步寻找匹配的处理代码。为此它会按顺序搜索调用栈,以看看是否存在带匹配的处理程序的封装try块。
下图阐明了这个搜索过程。图左边是代码的调用结构,右边是调用栈。该图显示Method2被从Method1的try块内部调用。如果异常发生在Method2内的try块内部,系统会执行以下操作。

  • 首先,它査看Method2是否有能处理该异常的异常处理程序
    • 如果有,Method2处理它,程序继续执行
    • 如果没有,系统再延着调用栈找到Method1,搜寻一个适当的处理程序
  • 如果Method1有一个适当的catch子句,那么系统将:
    • 回到栈顶,那里是Method2
    • 执行Method2的finally块,并把Method2弹出栈
    • 执行Method1的catch子句和它的finally块
  • 如果Method1没有适当的catch子句,系统会继续搜索调用栈。

一般法则

下图展示了处理异常的一般法则。

搜索调用栈的示例

在下面的代码中,Main开始执行并调用方法A,A调用方法B。代码之后给出了相应的说明, 并在图22-9中再现了整个过程。

class Program
{
    static void Main()
    {
        var MCls=new MyClass();
        try
        {
            MCls.A();
        }
        catch(DivideByZeroException e)
        {
            Console.WriteLine("catch clause in Main()");
        }
        finally
        {
            Console.WriteLine("finally clause in Main()");
        }
        Console.WriteLine("After try statement in Main.");
        Console.WriteLine("          -- keep running.");
    }
}
class MyClass
{
    public void A()
    {
        try
        {
            B();
        }
        catch(System.NullReferenceException)
        {
            Console.WriteLine("catch clause in A()");
        }
        finally
        {
            Console.WriteLine("finally clause in A()");
        }
    }
    void B()
    {
        int x=10,y=0;
        try
        {
            x/=y;
        }
        catch(System.IndexOutOfRangeException)
        {
            Console.WriteLine("catch clause in B()");
        }
        finally
        {
            Console.WriteLine("finally clause in B()");
        }
    }
}

这段代码产生以下输出:

  1. Main调用A,A调用B,B遇到一个DivideByZeroException异常
  2. 系统检查B的catch段寻找匹配的catch子句。虽然它有一个IndexOutOfRangeException的子句,但没有DivideByZeroException的
  3. 系统然后延着调用栈向下移动并检査A的catch段,在那里它发现A也没有匹配的catch子句
  4. 系统继续延调用栈向下,并检查Main的catch子句部分,在那里它发现Main确实有一个DivideByZeroException的catch子句
  5. 尽管匹配的catch子句现在被定位了,但并不执行。相反,系统回到栈的顶端,执行B的finally子句,并把B从调用栈中弹出
  6. 系统移动到A,执行它的finally子句,并把A从调用栈中弹出
  7. 最后,Main的匹配catch子句被执行,接着是它的finally子句。然后执行在Main的try语句结尾之后继续

抛出异常


可以使用throw语句使代码显式地引发一个异常。throw语句的语法如下:
throw ExceptionObject;
例如,下面的代码定义了一个名称为PrintArg的方法,它带一个string参数并把它打印出来。在try块内部,它首先做检査以确认该参数不是null。如果是null,它创建一个ArgumentNullException实例并抛出它。该异常实例在catch语句中被捕获,并且该出错消息被打印。Main调用该方法两次:一次用null参数,然后用一个有效参数。

class MyClass
{
    public static void PrintArg(string arg)
    {
        try
        {
            if(arg==null)
            {
                var myEx=new ArgumentNullException("arg");
                throw myEx;
            }
            Console.WriteLine(arg);
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("Message:  {0}",e.Message);
        }
    }
}
class Program
{
    static void Main()
    {
        string s=null;
        MyClass.PrintArg(s);
        MyClass.PrintArg("Hi there!");
    }
}

这段代码产生以下输出:

不带异常对象的抛出


throw语句还可以不带异常对象使用,在catch块内部。

  • 这种形式重新抛出当前异常,系统继续它的搜索,为该异常寻找另外的处理代码
  • 这种形式只能用在catch语句内部

例如,下面的代码从第一个catch子句内部重新抛出异常:

class MyClass
{
    public static void PrintArg(string arg)
    {
        try
        {
            try
            {
                if(arg==null)
                {
                    var myEx=new ArgumentNullException("arg");
                    throw myEx;
                }
                Console.WriteLine(arg);
            }
            catch(ArgumentNullException e)
            {
                Console.WriteLine("Inner Catch:  {0}",e.Message);
                throw;
            }
        }
        catch
        {
            Console.WriteLine("Outer Catch:  Handling an Exception.");
        }
    }
}
class Program
{
    static void Main()
    {
        string s=null;
        MyClass.PrintArg(s);
    }
}

这段代码产生以下输出:

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

posted @ 2017-09-13 16:23  只追昭熙  阅读(1339)  评论(0编辑  收藏  举报