【转】Effective C#原则：调用Dispose()方法

本文介绍了Effective C#原则：调用Dispose()方法，任何时候你在调用Dispose()方法的类型时，你就有责任来调用Dispose()方法来释放资源。

 

学习C#时，经常会遇到Effective C#原则问题，这里将介绍调用Dispose()方法解决Effective C#原则问题。

Effective C#原则（一）

使用非托管资源的类型必须实现IDisposable接口的Dispose()方法来精确的释放系统资源。.Net环境的这一规则使得释放资源代码的职责是类型的使用者，而不是类型或系统。因此，任何时候你在调用Dispose()方法的类型时，你就有责任来调用Dispose()方法来释放资源。最好的方法来保证Dispose()被调用的结构是使用using语句或者try/finally块。

所有包含非托管资源的类型应该实现IDisposable接口，另外，当你忘记恰当的处理这些类型时，它们会被动的创建析构函数。如果你忘记处理这些对象，那些非内存资源会在晚些时候，析构函数被确切调用时得到释放。这就使得这些对象在内存时待的时间更长，从而会使你的应用程序会因系统资源占用太多而速度下降。

幸运的是，C＃语言的设计者精确的释放资源是一个常见的任务。他们添加了一个关键字来使这变得简单了。

假设你写了下面的代码：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. SqlConnection myConnection = new SqlConnection( connString );
  4. SqlCommand mySqlCommand = new SqlCommand( commandString,
  5. myConnection );
  6. myConnection.Open();
  7. mySqlCommand.ExecuteNonQuery();
  8. }

这个例子中的两个可处理对象没有被恰当的释放：SqlConnection和SqlCommand。两个对象同时保存在内存里直到析构函数被调用。(这两个类都是从System.ComponentModel.Component继承来的。)

解决这个问题的方法就是在使用完命令和链接后就调用它们的Dispose:

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. SqlConnection myConnection = new SqlConnection( connString );
  4. SqlCommand mySqlCommand = new SqlCommand( commandString,
  5. myConnection );
  6. myConnection.Open();
  7. mySqlCommand.ExecuteNonQuery();
  8. mySqlCommand.Dispose( );
  9. myConnection.Dispose( );
  10. }

Effective C#原则（二）

这很好，除非SQL命令在执行时抛出异常，这时你的Dispose()调用就永远不会成功。using语句可以调用Dispose()方法。当你把对象分配到using语句内时，C＃的编译器就把这些对象放到一个try/finally块内：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. using ( SqlConnection myConnection = new SqlConnection( connString ))
  4. {
  5. using ( SqlCommand mySqlCommand = new SqlCommand( commandString, myConnection ))
  6. {
  7. myConnection.Open();
  8. mySqlCommand.ExecuteNonQuery();
  9. }
  10. }
  11. }

当你在一个函数内使用一个可处理对象时，using语句是最简单的方法来保证这个对象被恰当的处理掉。当这些对象被分配时，会被编译器放到一个try/finally块中。下面的两段代码编译成的IL是一样的：

  1. SqlConnection myConnection = null;
  2. // Example Using clause:
  3. using ( myConnection = new SqlConnection( connString ))
  4. {
  5. myConnection.Open();
  6. }
  7. // example Try / Catch block:
  8. try {
  9. myConnection = new SqlConnection( connString );
  10. myConnection.Open();
  11. }
  12. finally {
  13. myConnection.Dispose( );
  14. }

(译注：就我个人对try/catch/finally块的使用经验而言，我觉得上面这样的做法非常不方便。可以保证资源得到释放，却无法发现错误。关于如何同时抛出异常又释放资源的方法可以参考一下其它相关资源，如Jeffrey的.Net框架程序设计,修订版)

如果你把一个不能处理类型的变量放置在using语句内，C＃编译器给出一个错误，例如：

  1. // Does not compile:
  2. // String is sealed, and does not support IDisposable.
  3. using( string msg = "This is a message" )
  4. Console.WriteLine( msg );

using只能在编译时，那些支持IDispose接口的类型可以使用，并不是任意的对象：

  1. // Does not compile.
  2. // Object does not support IDisposable.
  3. using ( object obj = Factory.CreateResource( ))
  4. Console.WriteLine( obj.ToString( ));

如果obj实现了IDispose接口，那么using语句就会生成资源清理代码，如果不是，using就退化成使用using(null)，这是安全的，但没有任何作用。如果你对一个对象是否应该放在using语句中不是很确定，宁可为了更安全：假设要这样做，而且按前面的方法把它放到using语句中。

Effective C#原则（三）

这里讲了一个简单的情况：无论何时，当你在某个方法内使用一个可处理对象时，把这个对象放在using语句内。现在你学习一些更复杂的应用。还是前面那个例子里须要释放的两个对象：连接对象和命令对象。前面的例子告诉你创建了两个不同的using语句，一个包含一个可处理对象。每个using语句就生成了一个不同的try/finally块。等效的你写了这样的代码：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. SqlConnection myConnection = null;
  4. SqlCommand mySqlCommand = null;
  5. try
  6. {
  7. myConnection = new SqlConnection( connString );
  8. try
  9. {
  10. mySqlCommand = new SqlCommand( commandString,
  11. myConnection );
  12. myConnection.Open();
  13. mySqlCommand.ExecuteNonQuery();
  14. }
  15. finally
  16. {
  17. if ( mySqlCommand != null )
  18. mySqlCommand.Dispose( );
  19. }
  20. }
  21. finally
  22. {
  23. if ( myConnection != null )
  24. myConnection.Dispose( );
  25. }
  26. }

每一个using语句生成了一个新的嵌套的try/finally块。我发现这是很糟糕的结构，所以，如果是遇到多个实现了IDisposable接口的对象时，我更愿意写自己的try/finally块：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. SqlConnection myConnection = null;
  4. SqlCommand mySqlCommand = null;
  5. try {
  6. myConnection = new SqlConnection( connString );
  7. mySqlCommand = new SqlCommand( commandString,
  8. myConnection );
  9. myConnection.Open();
  10. mySqlCommand.ExecuteNonQuery();
  11. }
  12. finally
  13. {
  14. if ( mySqlCommand != null )
  15. mySqlCommand.Dispose();
  16. if ( myConnection != null )
  17. myConnection.Dispose();
  18. }
  19. }

(译注：作者里的判断对象是否为null是很重要的，特别是一些封装了COM的对象，有些时候的释放是隐式的，当你再释放一些空对象时会出现异常。例如：同一个COM被两个不同接口的变量引用时，在其中一个上调用了Dispose后，另一个的调用就会失败。在.Net里也要注意这样的问题，所以要判断对象是否为null)

然而，请不要自作聪明试图用as来写这样的using语句：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. // Bad idea. Potential resource leak lurks!
  4. SqlConnection myConnection = new SqlConnection( connString );
  5. SqlCommand mySqlCommand = new SqlCommand( commandString, myConnection );
  6. using ( myConnection as IDisposable )
  7. using (mySqlCommand as IDisposable )
  8. {
  9. myConnection.Open();
  10. mySqlCommand.ExecuteNonQuery();
  11. }
  12. }

这看上去很清爽，但有一个狡猾的(subtle )的bug。 如果SqlCommand()的构造函数抛出异常，那么SqlConnection对象就不可能被处理了。你必须确保每一个实现了IDispose接口的对象分配在在using范围内，或者在try/finally块内。否则会出现资源泄漏。

目前为止，你已经学会了两种最常见的情况。无论何时在一个方法内处理一个对象时，使用using语句是最好的方法来确保申请的资源在各种情况下都得到释放。当你在一个方法里分配了多个(实现了IDisposable接口的)对象时，创建多个using块或者使用你自己的try/finally块。

对可处理对象的理解有一点点细微的区别。有一些对象同时支持Disponse和Close两个方法来释放资源。SqlConnection就是其中之一，你可以像这样关闭SqlConnection：

  1. publicvoid ExecuteCommand( string connString, string commandString )
  2. {
  3. SqlConnection myConnection = null;
  4. try {
  5. myConnection = new SqlConnection( connString );
  6. SqlCommand mySqlCommand = new SqlCommand( commandString,
  7. myConnection );
  8. myConnection.Open();
  9. mySqlCommand.ExecuteNonQuery();
  10. }
  11. finally
  12. {
  13. if ( myConnection != null )
  14. myConnection.Close();
  15. }
  16. }

这个版本关闭了链接，但它确实与处理对象是不一样的。Dispose方法会释放更多的资源，它还会告诉GC，这个对象已经不再须要析构了(译注：关于C#里的析构，可以参考其它方面的书籍)。调用Dispose()方法的GC.SuppressFinalize()，但Close()一般不会。结果就是，对象会到析构队列中排队，即使析构并不是须要的。当你有选择时，Dispose()比Colse()要好。你会在原则18里学习更更精彩的内容。

Dispose()并不会从内存里把对象移走，对于让对象释放非托管资源来说是一个hook。这就是说你可能遇到这样的难题，就是释放一个还在使用的对象。不要释放一个在程序其它地方还在引用的对象。

在某些情况下，C#里的资源管理比C++还要困难。你不能指望确定的析构函数来清理你所使用的所有资源。但垃圾回收器却让你更轻松，你的大从数类型不必实现IDisposable接口。在.Net框架里的1500多个类中，只有不到100个类实现了IDisposable接口。当你使用一个实现了IDisposeable接口的对象时，记得在所有的类里都要处理它们。你应该把它们包含在using语句中，或者try/finally块中。不管用哪一种，请确保每时每刻对象都得到了正确的释放。

以上内容转自：http://developer.51cto.com/art/200909/151182.htm

关于红色部分的注释：
实际上，红色部分的文字已经解释得非常清楚了，就是说实现了IDisposelbe接口的类，在我们在使用完后，即使没有去显式的释放它所占有的资源。晚些时候它还是会在析构函数中被释放的。
下面是我做一个个例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;

namespace 稀有资源的垃圾回收
{
    class Program
    {
        static void Main(string[] args)
        {
            string strSql = @"Data Source=.\SQLEXPRESS;AttachDbFilename=F:\稀有资源的垃圾回收\稀有资源的垃圾回收\Test.mdf;Integrated Security=True;User Instance=True";

            for (int i = 1; i < 500; i++)
            {
                SqlConnection conn = new SqlConnection(strSql);
                conn.Open();
                GC.Collect();
                Console.WriteLine(i);

            }
            Console.Read();
        }
    }
}

 在这个例子中，数据库连接池中的连接数据量本来是没有500的，而我每调用一次open方法，就会打开一个连接，如果这个连接没有被释放掉（一般是说用conn.Dispose();来进行释放），这个程序就会在达到最大数量的时候报异常。而这里我们看到时的结果却是下面这样。

 

这也就说明了：垃圾回收还是可以释放这些资源的。只是会晚一些。
下一篇转载的文章中有较详细的解释

posted @ 2012-11-28 09:26  伯箫  阅读(401)  评论(0)  编辑  收藏  举报