&gt; 第七章异常处理（rainbow 翻译）（来自重粒子空间）

2024-07-21 02:28:07

字体：大中小

来源：转载

供稿：网友

<<展现c#>> 第七章异常处理（rainbow 翻译）

出处：http://www.informit.com/matter/ser0000002

正文：

第七章   异常处理

    通用语言运行时（clr）具有的一个很大的优势为，异常处理是跨语言被标准化的。一个在c#中所引发的异常可以在visual basic客户中得到处理。不再有 hresults  或者 isupporterrorinfo 接口。
    尽管跨语言异常处理的覆盖面很广，但这一章完全集中讨论c#异常处理。你稍为改变编译器的溢出处理行为，接着有趣的事情就开始了：你处理了该异常。要增加更多的手段，随后引发你所创建的异常。

7.1  校验(checked)和非校验(unchecked)语句
    当你执行运算时，有可能会发生计算结果超出结果变量数据类型的有效范围。这种情况被称为溢出，依据不同的编程语言，你将被以某种方式通知——或者根本就没有被通知。（c++程序员听起来熟悉吗？）
     那么，c#如何处理溢出的呢？要找出其默认行为，请看我在这本书前面提到的阶乘的例子。（为了方便其见，前面的例子再次在清单 7.1 中给出）

清单 7.1     计算一个数的阶乘

1: using system;
2:
3: class factorial
4: {
5:  public static void main(string[] args)
6:  {
7:   long nfactorial = 1;
8:   long ncomputeto = int64.parse(args[0]);
9:
10:   long ncurdig = 1;
11:   for (ncurdig=1;ncurdig <= ncomputeto; ncurdig++)
12:    nfactorial *= ncurdig;
13:
14:   console.writeline("{0}! is {1}",ncomputeto, nfactorial);
15:  }
16: }

    当你象这样使用命令行执行程序时
    factorial 2000

    结果为0，什么也没有发生。因此，设想c#默默地处理溢出情况而不明确地警告你是安全的。
     通过给整个应用程序（经编译器开关）或于语句级允许溢出校验，你就可以改变这种行为。以下两节分别解决一种方案。
7.1.1 给溢出校验设置编译器
    如果你想给整个应用程序控制溢出校验，c#编译器设置选择是正是你所要找的。默认地，溢出校验是禁用的。要明确地要求它，运行以下编译器命令：
csc factorial.cs /checked+

    现在当你用2000参数执行应用程序时，clr通知你溢出异常（见图 7.1）。

图 7.1　允许了溢出异常，阶乘代码产生了一个异常。

　　按ｏｋ键离开对话框揭示了异常信息：
exception occurred: system.overflowexception
  at factorial.main(system.string[])

　　现在你了解了溢出条件引发了一个 system.overflowexception异常。下一节，在我们完成语法校验之后，如何捕获并处理所出现的异常？
7.1.2　语法溢出校验
　　如果你不想给整个应用程序允许溢出校验，仅给某些代码段允许校验，你可能会很舒适。对于这种场合，你可能象清单7.2中显示的那样，使用校验语句。

清单 7.2　　阶乘计算中的溢出校验

1: using system;
2:
3: class factorial
4: {
5:  public static void main(string[] args)
6:  {
7:   long nfactorial = 1;
8:   long ncomputeto = int64.parse(args[0]);
9:
10:   long ncurdig = 1;
11:
12:   for (ncurdig=1;ncurdig <= ncomputeto; ncurdig++)
13:    checked { nfactorial *= ncurdig; }
14:
15:   console.writeline("{0}! is {1}",ncomputeto, nfactorial);
16:  }
17: }

　　甚至就如你运用标志 checked-编译了该代码，在第13行中，溢出校验仍然会对乘法实现检查。错误信息保持一致。

　　显示相反行为的语句是非校验（unchecked ）。甚至如果允许了溢出校验（给编译器加上checked+标志），被unchecked 语句所括住的代码也将不会引发溢出异常：

unchecked
{
nfactorial *= ncurdig;
}



7.2 　异常处理语句
　　既然你知道了如何产生一个异常（你会发现更多的方法，相信我），仍然存在如何处理它的问题。如果你是一个 c++ win32 程序员，肯定熟悉seh（结构异常处理）。你将从中找到安慰，ｃ＃中的命令几乎是相同的，而且它们也以相似的方式运作。

the following three sections introduce c#'s exception-handling statements:
  以下三节介绍了ｃ＃的异常处理语句：

。用 try-catch 捕获异常
。用try-finally 清除异常
。用try-catch-finally 处理所有的异常

7.2.1 　使用 try 和 catch捕获异常
　　你肯定会对一件事非常感兴趣——不要提示给用户那令人讨厌的异常消息，以便你的应用程序继续执行。要这样，你必须捕获（处理）该异常。
    这样使用的语句是try 和 catch。try包含可能会产生异常的语句，而catch处理一个异常，如果有异常存在的话。清单7.3 用try 和 catch为overflowexception 实现异常处理。

   清单7.3  捕获由factorial calculation引发的overflowexception 异常

1: using system;
2:
3: class factorial
4: {
5:  public static void main(string[] args)
6:  {
7:   long nfactorial = 1, ncurdig=1;
8:   long ncomputeto = int64.parse(args[0]);
9:
10:   try
11:   {
12:    checked
13:    {
14:     for (;ncurdig <= ncomputeto; ncurdig++)
15:      nfactorial *= ncurdig;
16:    }
17:   }
18:   catch (overflowexception oe)
19:   {
20:    console.writeline("computing {0} caused an overflow exception", ncomputeto);
21:    return;
22:   }
23:
24:   console.writeline("{0}! is {1}",ncomputeto, nfactorial);
25:  }
26: }

    为了说明清楚，我扩展了某些代码段，而且我也保证异常是由checked 语句产生的，甚至当你忘记了编译器设置时。
    正如你所见，异常处理并不麻烦。你所有要做的是：在try语句中包含容易产生异常的代码，接着捕获异常，该异常在这个例子中是overflowexception类型。无论一个异常什么时候被引发，在catch段里的代码会注意进行适当的处理。
    如果你不事先知道哪一种异常会被预期，而仍然想处于安全状态，简单地忽略异常的类型。

try
{
...
}
catch
{
...
}

    但是，通过这个途径，你不能获得对异常对象的访问，而该对象含有重要的出错信息。一般化异常处理代码象这样：

try
{
...
}
catch(system.exception e)
{
...
}

    注意，你不能用ref或out 修饰符传递 e 对象给一个方法，也不能赋给它一个不同的值。

7.2.2  使用 try 和 finally 清除异常
    如果你更关心清除而不是错误处理， try 和 finally 会获得你的喜欢。它不仅抑制了出错消息，而且所有包含在 finally 块中的代码在异常被引发后仍然会被执行。
    尽管程序不正常终止，但你还可以为用户获取一条消息，如清单 7.4 所示。

    清单 7.4  在finally 语句中处理异常

1: using system;
2:
3: class factorial
4: {
5:  public static void main(string[] args)
6:  {
7:   long nfactorial = 1, ncurdig=1;
8:   long ncomputeto = int64.parse(args[0]);
9:   bool ballfine = false;
10:
11:   try
12:   {
13:    checked
14:    {
15:     for (;ncurdig <= ncomputeto; ncurdig++)
16:      nfactorial *= ncurdig;
17:    }
18:    ballfine = true;
19:   }
20:   finally
21:   {
22:    if (!ballfine)
23:     console.writeline("computing {0} caused an overflow exception", ncomputeto);
24:    else
25:     console.writeline("{0}! is {1}",ncomputeto, nfactorial);
26:   }
27:  }
28: }

    通过检测该代码，你可能会猜到，即使没有引发异常处理，finally也会被执行。这是真的——在finally中的代码总是会被执行的，不管是否具有异常条件。为了举例说明如何在两种情况下提供一些有意义的信息给用户，我引进了新变量ballfine。ballfine告诉finally 语段，它是否是因为一个异常或者仅是因为计算的顺利完成而被调用。
    作为一个习惯了seh程序员，你可能会想，是否有一个与__leave 语句等价的语句，该语句在c++中很管用。如果你还不了解，在c++中的__leave 语句是用来提前终止 try  语段中的执行代码，并立即跳转到finally 语段。
    坏消息， c# 中没有__leave 语句。但是，在清单 7.5 中的代码演示了一个你可以实现的方案。

    清单 7.5  从 try语句跳转到finally 语句

1: using system;
2:
3: class jumptest
4: {
5:  public static void main()
6:  {
7:   try
8:   {
9:    console.writeline("try");
10:    goto __leave;
11:   }
12:   finally
13:   {
14:    console.writeline("finally");
15:   }
16:
17:   __leave:
18:   console.writeline("__leave");
19:  }
20: }

    当这个应用程序运行时，输出结果为

try
finally
__leave

     一个 goto 语句不能退出一个finally 语段。甚至把 goto 语句放在 try 语句段中，还是会立即返回控制到 finally 语段。因此，goto 只是离开了 try 语段并跳转到finally 语段。直到 finally 中的代码完成运行后，才能到达__leave 标签。按这种方式，你可以模仿在seh中使用的的__leave 语句。
     顺便地，你可能怀疑goto 语句被忽略了，因为它是try 语句中的最后一条语句，并且控制自动地转移到了 finally 。为了证明不是这样，试把goto 语句放到console.writeline 方法调用之前。尽管由于不可到达代码你得到了编译器的警告，但是你将看到goto语句实际上被执行了，且没有为 try 字符串产生的输出。

7.2.3  使用try-catch-finally处理所有异常
    应用程序最有可能的途径是合并前面两种错误处理技术——捕获错误、清除并继续执行应用程序。所有你要做的是在出错处理代码中使用 try 、catch 和 finally语句。清单 7.6 显示了处理零除错误的途径。

    清单 7.6  实现多个catch 语句

1: using system;
2:
3: class catchit
4: {
5:  public static void main()
6:  {
7:   try
8:   {
9:    int nthezero = 0;
10:    int nresult = 10 / nthezero;
11:   }
12:   catch(dividebyzeroexception divex)
13:   {
14:    console.writeline("divide by zero occurred!");
15:   }
16:   catch(exception ex)
17:   {
18:    console.writeline("some other exception");
19:   }
20:   finally
21:   {
22:   }
23:  }
24: }

    这个例子的技巧为，它包含了多个catch 语句。第一个捕获了更可能出现的dividebyzeroexception异常，而第二个catch语句通过捕获普通异常处理了所有剩下来的异常。
    你肯定总是首先捕获特定的异常，接着是普通的异常。如果你不按这个顺序捕获异常，会发生什么事呢？清单7.7中的代码有说明。

  清单7.7   顺序不适当的 catch 语句

1:   try
2:   {
3:    int nthezero = 0;
4:    int nresult = 10 / nthezero;
5:   }
6:   catch(exception ex)
7:   {
8:    console.writeline("exception " + ex.tostring());
9:   }
10:   catch(dividebyzeroexception divex)
11:   {
12:    console.writeline("never going to see that");
13:   }

    编译器将捕获到一个小错误，并类似这样报告该错误：
wrongcatch.cs(10,9): error cs0160: a previous catch clause already
catches all exceptions of this or a super type ('system.exception')

    最后，我必须告发clr异常与seh相比时的一个缺点（或差别）：没有 exception_continue_execution标识符的等价物，它在seh异常过滤器中很有用。基本上，exception_continue_execution 允许你重新执行负责异常的代码片段。在重新执行之前，你有机会更改变量等。我个人特别喜欢的技术为，使用访问违例异常，按需要实施内存分配。


7.3  引发异常
    当你必须捕获异常时，其他人首先必须首先能够引发异常。而且，不仅其他人能够引发，你也可以负责引发。其相当简单：

throw new argumentexception("argument can't be 5");
    你所需要的是throw 语句和一个适当的异常类。我已经从表7.1提供的清单中选出一个异常给这个例子。

    表 7.1   runtime提供的标准异常

异常类型                                                        描述

exception                                            所有异常对象的基类
systemexception                                      运行时产生的所有错误的基类
indexoutofrangeexception                             当一个数组的下标超出范围时运行时引发
nullreferenceexception                               当一个空对象被引用时运行时引发
invalidoperationexception                            当对方法的调用对对象的当前状态无效时，由某些方法引发
argumentexception                                    所有参数异常的基类
argumentnullexception                                在参数为空（不允许）的情况下，由方法引发
argumentoutofrangeexception                          当参数不在一个给定范围之内时，由方法引发
interopexception                                     目标在或发生在clr外面环境中的异常的基类
comexception                                         包含com 类的hresult信息的异常
sehexception                                         封装win32 结构异常处理信息的异常

    然而，在catch语句的内部，你已经有了随意处置的异常，就不必创建一个新异常。可能在表7.1 中的异常没有一个符合你特殊的要求——为什么不创建一个新的异常？在即将要学到小节中，都涉及到这两个话题。

7.3.1 重新引发异常
    当处于一个catch 语句的内部时，你可能决定引发一个目前正在再度处理的异常，留下进一步的处理给一些外部的try-catch 语句。该方法的例子如清单7.8所示。

清单 7.8  重新引发一个异常

1:   try
2:   {
3:    checked
4:    {
5:     for (;ncurdig <= ncomputeto; ncurdig++)
6:      nfactorial *= ncurdig;
7:    }
8:   }
9:   catch (overflowexception oe)
10:   {
11:    console.writeline("computing {0} caused an overflow exception", ncomputeto);
12:    throw;
13:   }

    注意，我不必规定所声明的异常变量。尽管它是可选的，但你也可以这样写：
    throw oe;
    现在有时还必须留意这个异常。

7.3.2  创建自己的异常类
    尽管建议使用预定义的异常类，但对于实际场合，创建自己的异常类可能会方便。创建自己的异常类，允许你的异常类的使用者根据该异常类采取不同的手段。
    在清单 7.9 中出现的异常类 myimportantexception遵循两个规则：第一，它用exception结束类名。第二，它实现了所有三个被推荐的通用结构。你也应该遵守这些规则。
    清单  7.9   实现自己的异常类  myimportantexception

1: using system;
2:
3: public class myimportantexception:exception
4: {
5:  public myimportantexception()
6:   :base() {}
7:
8:  public myimportantexception(string message)
9:   :base(message) {}
10:
11:  public myimportantexception(string message, exception inner)
12:   :base(message,inner) {}
13: }
14:
15: public class exceptiontestapp
16: {
17:  public static void testthrow()
18:  {
19:   throw new myimportantexception("something bad has happened.");
20:  }
21:
22:  public static void main()
23:  {
24:   try
25:   {
26:    exceptiontestapp.testthrow();
27:   }
28:   catch (exception e)
29:   {
30:    console.writeline(e);
31:   }
32:  }
33: }

    正如你所看到的，myimportantexception 异常类不能实现任何特殊的功能，但它完全基于system.exception类。程序的剩余部分测试新的异常类，给system.exception 类使用一个catch 语句。
    如果没有特殊的实现而只是给myimportantexception定义了三个构造函数，创建它又有什么意义呢？它是一个重要的类型——你可以在catch语句中使用它，代替更为普通的异常类。可能引发你的新异常的客户代码可以按规定的catch代码发挥作用。
    当使用自己的名字空间编写一个类库时，也要把异常放到该名字空间。尽管它并没有出现在这个例子中，你还是应该使用适当的属性，为扩展了的错误信息扩充你的异常类。

7.4  异常处理的“要”和“不要”
  作为最后的忠告之语，这里是对异常引发和处理所要做和不要做的清单：
。当引发异常时，要提供有意义的文本。
。要引发异常仅当条件是真正异常；也就是当一个正常的返回值不满足时。
。如果你的方法或属性被传递一个坏参数，要引发一个argumentexception异常。
。当调用操作不适合对象的当前状态时，要引发一个 invalidoperationexception异常。
。要引发最适合的异常。
。要使用链接异常，它们允许你跟踪异常树。
。不要为正常或预期的错误使用异常。
。不要为流程的正常控制使用异常。
。不要在方法中引发 nullreferenceexception或indexoutofrangeexception异常。

   7.5  小结
    这一章由介绍溢出校验开始。你可以使用编译器开关（默认是关），使整个应用程序允许或禁止溢出校验。如果需要微调控制，你可以使用校验和非校验语句，它允许你使用或不使用溢出校验来执行一段代码，尽管没有给应用程序设置开关。
    当发生溢出时，一个异常就被引发了。如何处理异常取决于你。我提出了各种途径，包括你最有可能贯穿整个应用程序使用的：try、catch 和finally 语句。在伴随的多个例子中，你学到了它与win32结构异常处理（seh）的差别。
   异常处理是给类的用户；然而，如果你负责创建新的类，就可以引发异常。有多种选择：引发早已捕获的异常，引发存在的框架异常，或者按规定的实际目标创建新的异常类。
   最后，你需要阅读引发和处理异常的各种“要”和