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

时间  2019-12-10
标签 c# 图解 教程 第二 十二 异常 栏目 C# 繁體版
原文   原文链接
异常
什么是异常
try语句
处理异常
异常类
catch 子句
使用特定catch子句的示例
catch子句段
finally块
为异常寻找处理程序
更进一步搜索
通常法则
搜索调用栈的示例
抛出异常
不带异常对象的抛出

异常

什么是异常

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

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

当这段代码运行时，系统显示下面的错误信息：
3d

try语句

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

  • 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");
    }
}

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

异常类

有许多不一样类型的异常能够在程序中发生。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类的异常。string

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

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

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;">

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程