异常
什么是异常
异常是程序中的运行时错误，它违反了系统约束或应用程序约束，或出现了在正常操作时未预料的情形。例如，程序试图除以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()");
}
}
}这段代码产生以下输出： 
- Main调用A，A调用B，B遇到一个DivideByZeroException异常
- 系统检查B的catch段寻找匹配的catch子句。虽然它有一个IndexOutOfRangeException的子句，但没有DivideByZeroException的
- 系统然后延着调用栈向下移动并检査A的catch段，在那里它发现A也没有匹配的catch子句
- 系统继续延调用栈向下，并检查Main的catch子句部分，在那里它发现Main确实有一个DivideByZeroException的catch子句
- 尽管匹配的catch子句现在被定位了，但并不执行。相反，系统回到栈的顶端，执行B的finally子句，并把B从调用栈中弹出
- 系统移动到A，执行它的finally子句，并把A从调用栈中弹出
- 最后，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;">