加入收藏 | 网站地图 | | RSS | WAP
你好,游客 登录 注册 搜索

.NET异常代码编写

[日期:2005-03-12] 作者:未知 来源:网络 [字体: ]
 为什么使用异常(Exceptions)

  从错误代码转换到异常处理会对你的代码风格产生很大影响。要用一种不同的方法编写程序,需要你培养一套新的编程习惯,在你开始努力这么做之前,这篇文章会让你知道你的努力将非常有意义。

  错误代码的使用已经有相当长的一段时间了。如果你在C++ 中编写代码,通常是下面的形式:

HRESULT retval = query.FetchRow();
if (FAILED(retval))
{
// error handling here
}

  使用错误代码的真正问题是返回的代码不是很好。尽管从理论上讲,错误代码可以正确处理程序中所有的错误,但总有一些问题是你无法预先知道的。一些传统编程模型的脆弱性就是源于不正确的错误处理;编写正确的代码并不容易.

  问题的症结在于错误代码这种方法要求程序员去完成人类不擅长的工作--任何时候的一致性和完整性,并且系统环境没有给你任何帮助。异常(Exception)将使这一切变得容易很多。

  是Opt Out而不是Opt In

  错误代码和异常最重要的不同在于对"做正确的事情"的要求不一样。错误代码使用的是Opt in,如果代码中对错误没有做明确的处理,那么这个错误就会被忽略。

  而异常(Exceptions)使用的是Opt Out模型。在默认情况下,运行时(runtime)会根据这些异常(exceptions)做正确的处理。

  这个区别对编写的代码有着很重要的影响。因为运行时(Runtime)能对问题进行常规的处理,所以程序员就可以将精力放在那些需要特殊处理的问题。这可以使我们能用更少的精力却得到更为健壮的代码。光这一个好处就足以促成向异常(exception)的转变,更何况异常(exception)还有一个重要的优势。

  更多的信息

  在编写新代码时,写出的代码不能正常工作是很常见的。你可能会从某个函数那得到诸如"0x80001345"类似的返回值,接下来你就不得不想办法判断出其中的含义。

  你首先要做的就是把这个返回值翻译成某种类型的符号代码。虽然可能会有更好的办法,但我通常是去查找 .h 文件中的常量。在找到之后,你需要打开MSDN来找出这代码的含义,最后才能决定如何修改程序。这还是在你幸运的情况下,有时候你更本就无法找到与错误码对应的符号代码。

  有时候即使你找到了错误代码,也没有什么帮助。如果得到的错误码是ERROR_BAD_ARGUMENTS,我知道这是由给出的某个参数不正确引起的,但我不知道是哪一个。我调用的那个函数虽然知道,但它无法告诉我是哪一个出了问题。

  有了异常机制,我除了能得到一个名字告诉我发生了哪一种错误,而且还能得到一个更具体的信息。例如,如果我传递了一个错误的参数,exception会告诉我哪一个参数错了。这节省了大量的时间。

  更好的是,exception信息还能给出提示,教你如何去解决问题。今年早些时候,我试着将Beta1 的代码移植到Beta2中,当我运行程序的时候,程序抛出一个如下的异常(exception):

"Paint operation cannot be performed on this thread. Use Control.Invoke() instead"


  升级了的Beta2代码会检查不正确的用法,如果找到了,就抛出一个异常(exception)并确切地告诉程序员如何去解决这个问题。要修改这么一个错误真的是很简单。


  异常(exception)处理和性能

  当异常(exception)处理机制加入到C++时,它由于减慢了代码的执行速度而没得到好的声誉,使用了异常处理的代码可能会比不使用的慢一点。有一些不好的说法是可以理解的,尽管应该指出没有使用异常处理的代码会因为没有对众多错误进行检查而经常出问题。

  随着时间的过去,C++中异常处理的开销减少了,但并没有减到零。为了恰当地实现异常处理,C++编译器必须在抛出异常(exception)的地方决定要创建哪些对象(这些对象使用完后需要释放),然后生成代码去检查异常(exception),并在异常检测完后正确地清理这些对象。这些代码会产生副作用,加大了代码优化的难度,所以还是会为此而损失性能。只要是使用C++,异常(exception)就会影响性能。

  .NET世界使这一切对编译器编写者来说容易了很多。运行时(Runtime)对代码的运行了如指掌,.NET编译器不必再去检测异常的发生。更重要的是,对象能被垃圾收集器(garbage collector)所收集,所以不用再去分析对象的不同状态。当异常(exception)出现时,垃圾收集器会恰当地做好清理工作。这意味着在不出现异常(non-exceptional)的情况下不会有任何额外的开销。

  使用异常处理(exception handling)

  我想我已经让你深信异常处理(exception handling)是一个好的思想,现在该到了了解如何去写代码实现异常处理的时候了。

  Throw
  当一个异常情况出现时,它会被throw语句抛出。比如,如果一个函数需要一个非空字符串作为参数,它可能会含有下列代码:

public void Process(string location)
{
if (location == null)
throw new ArgumentNullException("null value", "location");
}

在这个例子中,用特定的信息和参数名创建了一个ArgumentNullException的新实例,并用throw语句将其抛出。

  Try-Catch

  编写错误处理最基本的结构就是try-catch。看下面的代码:

try
{
 Process(currentLocation);
 Console.WriteLine("Done processing");
}
catch (ArgumentNullException e)
{
 // handle the exception here
}

  在这例子中,如果try代码块(本例中就是Process()函数) 中的代码抛出一个ArgumentNullException异常,控制权就会马上转移到catch代码段,而不去执行Console.WriteLine()调用。


  更多通用的Catching

  在前面的例子中,catch语句捕获了一个ArgumentNullException,它和Process()抛出的异常相匹配。但是这并不是必需的。一个catch语句能捕获某指定的异常(exception)或任何从这个类继承的异常(exceptions)。例如:

try
{
Process(currentLocation);
Console.WriteLine("Done processing");
}
catch (ArgumentException e)
{
// handle the exception here
}

  因为ArgumentNullException是从ArgumentException继承而来的,所以这个catch语句也能捕获ArgumentNullException异常。另外,它还能捕获其他继承而来的异常:ArgumentOutOfRangeException、InvalidEnumArgumentException和

  DuplicateWaitObjectException。

  既然所有的异常(exceptions)最终都是从Exception类衍生出来的,那么只要对Exception类进行捕获,就能捕获任何其他的异常(exception)。C++没有限制用户只能抛出Exception的导出类,C#提供了一种能捕获所有异常的语法:

catch
{
// handle the exception here
}

  尽管这个语法适用于所有的异常,但它没什么实际利用价值。大部分C++程序员会选择抛出从Exception继承而来的异常,即使他们不这么做,这个catch 语法也没法让你确定抛出的是什么异常。


  Catch语句的排列顺序

  我们可以在一个try语句中放置多个catch语句,每个catch语句捕获一种不同类型的异常。在前面这个例子中,对ArgumentException做一个特殊的处理是挺有必要的,对其它的异常可以进行另外的处理。

  这个例子如下:

try
{
Process(currentLocation);
Console.WriteLine("Done processing");
}
catch (ArgumentException e)
{
 // handle the exception here
}
catch (Exception e)
{
 // handle the more general exception here
}
 
  当使用了多个catch语句时,导出类型必须列在它的任何基类之前。这有助于提高可读性。你可以更早地判断出运行时(Runtime)的行为。

  Catch Operations

  现在我们捕获了一个异常(exception),希望用它做一些有用的事。我们要做的第一件事就是想把这个异常用一些额外的上下文信息包装起来。

  我们用下面的方法来实现:

try
{
 Process(currentLocation);
 Console.WriteLine("Done processing");
}
catch (ArgumentException e)
{
 throw new ArgumentException("Error while processing", e);
}

  这里使用了ArgumentException的构造器,它接受了一个信息和一个异常。构造器把传递给它的这个异常用一个新的异常包装了起来并抛出。

  这个过程给开发者们提供了一种极大的便利。将异常包装起来就得到了类似于堆栈跟踪(stack trace)的结果,而不仅仅是一些关于异常的单一信息:

System.Exception: Exception in Test1
---> System.Exception: Exception in Test2
---> System.DivideByZeroException: Attempted to divide by zero.

  如果你在编译时使用了/debug开关,这样的输出将使大大方便调试。你还可以得到每一级的文件名和行号。

  异常(exceptioin)的包装在为调试提供额外的信息方面很有用。另外一种很有帮助的场合就是在你需要根据一个异常采取相应的行动的时候。把输出写入一个文件的实现代码应该像下面这样:

try
{
 FileStream f = new FileStream(filename, FileMode.Create);
 StreamWriter s = new StreamWriter(f);
 s.WriteLine("{0} {1}", "test", 55);
 s.Close();
 f.Close();
}
catch (IOException e)
{
 Console.WriteLine("Error opening file {0}", filename);
 Console.WriteLine(e);
}

  如果这个文件不能被打开,系统就抛出一个异常,catch语句就被触发,产生一个错误,程序可继续执行下去。在大多数情况下,这是没问题的。 但是当出现下面这种情况时问题就来了:一个异常出现在这个文件刚被打开后,这样该文件将无法被关闭,这是有害的。

  这里需要的是一种能保证即使在异常发生的情况下,文件仍能被关闭的方法。


  Try-Finally

  Finally 这个结构用来指定一段代码,即使在异常发生的情况下,这段代码也能够保证运行。通常,finally语句用来负责在异常发生后的清理工作。我们把前面的例子修改如下:

try
{
 FileStream f = new FileStream(filename, FileMode.Create);
 StreamWriter s = new StreamWriter(f);

 s.WriteLine("{0} {1}", "test", 55);
 s.Close();
 f.Close();
}
catch (IOException e)
{
 Console.WriteLine("Error opening file {0}", filename);
 Console.WriteLine(e);
}
finally
{
 if (f != null)
  f.Close();
}

  在这段修改过的代码中,即使发生了异常,finally语句也将被执行。

  Using和Lock语句

  前面我们看到的是一个非常常用的模式,C#提供了一种特殊的支持以促使程序员们写出正确的代码。Using语句可以被用来创建类似try-finally的代码:

using (FileStream f = new FileStream(filename, FileMode.Create))
{
 StreamWriter s = new StreamWriter(f);

 s.WriteLine("{0} {1}", "test", 55);
 s.Close();
 f.Close();
}
catch (IOException e)
{
 Console.WriteLine("Error opening file {0}", filename);
 Console.WriteLine(e);
}

  这段代码等同于前面的例子。

  Lock语句提供了一个类似的对System.Threading.Monitor类的包装,以保证即使在异常发生的情况下锁(locks)也能被释放。


  设计方针

  这个部分将讲述一些异常处理的设计方针。

  1、尽量捕捉明确的异常

   如果你的代码需要从一些异常中恢复过来,则要确信只捕获那些异常。如果你捕获更多的通用异常,这就与你错误地忽略这些异常没什么区别。

  2、只忽略你有把握的异常

   这是由前面那个方针推断而出的。当你忽略一个异常时,意味着你应该知道这个异常能引起的所有可能情况,并且你编写的恢复代码能够处理所有的这些情况。

  3、如果合适的话,尽量使用lock或using语句

   如果你能使用lock或using 语句,就尽量使用它们。它们使代码更具可读性,而且能使得你更少犯错误。
  4、如果可能的话,尽量包装异常

   如果你可以往一个异常中加入额外的信息的话,要尽一切办法做到。如果我要往另一个函数传递一个参数,那么加入这个参数的额外信息对我来说是很有帮助的。

try
{
 o.Process(v1, v2, v3);
 }
catch (ArgumentException e)
 {
  throw new ArgumentException("error updating contact information", e);
 }

  Catch语句将捕获到的表达式(expression)用同样的类型包装起来并抛出。这给了用户两个层次的信息。

  然而使用这种方法时要当心,在这个例子中,catch语句能够捕获ArgumentException异常和任何从这个类继承而来的异常(比如ArgumentNullException)。但我的调用者从来不会关心这些区别,只是抛出一个ArgumentException异常。

  这种方法的最坏情况就是将一个Exception这个异常包装并再次抛出。如果调用者需要对这个异常的真实类型进行解码,则必需用下面的代码:

try
{
 o.BadFunction();
}
catch (Exception e)
{
 if (e.Inner.GetType() == typeof(ArgumentException))
 {

 }
 else
  throw;
}

  这段代码检查每个被包装了的异常,要么处理它要么再次抛出它。如果你的用户不得不编写类似的代码,那么你的代码将受到严重影响。

关键词:代码 

收藏 推荐 打印 | 录入:blue1000 | 阅读:
本文评论   查看全部评论 (0)
表情: 姓名: 字数
点评:
       
评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事/刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款