今天看代码，看到IDispose然后牵涉到垃圾回收机制，最后又到Finalize折腾了一下午，现在终于了解.NET的一些运行机制了。

看到GC.SuppressFinalize方法（MSDN：中C#示例），代码如下：

using System; using System.ComponentModel; // The following example demonstrates how to use the // GC.SuppressFinalize method in a resource class to prevent // the clean-up code for the object from being called twice. public class DisposeExample {
    // A class that implements IDisposable. // By implementing IDisposable, you are announcing that // instances of this type allocate scarce resources.     public class MyResource: IDisposable     {
    // Pointer to an external unmanaged resource.         private IntPtr handle; // Other managed resource this class uses.         private Component component = new Component(); // Track whether Dispose has been called.         private bool disposed = false; // The class constructor.         public MyResource(IntPtr handle)         {
    this.handle = handle;         } // Implement IDisposable. // Do not make this method virtual. // A derived class should not be able to override this method.         public void Dispose()         {
                Dispose(true); // This object will be cleaned up by the Dispose method. // Therefore, you should call GC.SupressFinalize to // take this object off the finalization queue // and prevent finalization code for this object // from executing a second time.             GC.SuppressFinalize(this);//问题2：在“Dispose()”中“GC.SuppressFinalize(this);”是什么意思？         } // Dispose(bool disposing) executes in two distinct scenarios. // If disposing equals true, the method has been called directly // or indirectly by a user's code. Managed and unmanaged resources // can be disposed. // If disposing equals false, the method has been called by the // runtime from inside the finalizer and you should not reference // other objects. Only unmanaged resources can be disposed.         private void Dispose(bool disposing)         {
    // Check to see if Dispose has already been called.             if(!this.disposed)             {
    // If disposing equals true, dispose all managed // and unmanaged resources.                 if(disposing)                 {
    // Dispose managed resources.                     component.Dispose();//问题1：也就是为什么GC垃圾回收机制在回收对象的时候只回收或者释放非托管资源，而不回收托管资源？                 } // Call the appropriate methods to clean up // unmanaged resources here. // If disposing is false, // only the following code is executed.                 CloseHandle(handle);                 handle = IntPtr.Zero;                        }             disposed = true;                 } // Use interop to call the method necessary  // to clean up the unmanaged resource.         [System.Runtime.InteropServices.DllImport("Kernel32")] private extern static Boolean CloseHandle(IntPtr handle); // Use C# destructor syntax for finalization code. // This destructor will run only if the Dispose method // does not get called. // It gives your base class the opportunity to finalize. // Do not provide destructors in types derived from this class.         ~MyResource()              {
    // Do not re-create Dispose clean-up code here. // Calling Dispose(false) is optimal in terms of // readability and maintainability.             Dispose(false);//问题1：为什么在析构函数中调用的是“Dispose(false);”?         }     } public static void Main()     {
    // Insert code here to create // and use a MyResource object.     } }

产生了两个问题（代码中红色标注区域）：

问题1：为什么在析构函数中调用的是“Dispose(false);”,也就是为什么GC垃圾回收机制在回收对

象的时候只回收或者释放非托管资源，而不回收托管资源？

问题2：在“Dispose()”中“GC.SuppressFinalize(this);”是什么意思？

上网搜了写资料，终于了解了这种设计的用意和优点：

参考资料：

http://baike.baidu.com/view/4471636.htm

http://www.360doc.com/content/11/0503/18/6075898_114106056.shtml

解答问题1：

在.NET的对象中实际上有两个用于释放资源的函数：Dispose和Finalize。Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的。

在这个模式中，通过一个变量“disposing”来区分是客户调用（true）还是GC调用（false）。

这是因为，Dispose()函数是被其它代码显式调用并要求释放资源的，而Finalize是被GC调用的。

在GC调用的时候MyResource所引用的其它托管对象（component）可能还不需要被销毁，并且即使

要销毁，也会由GC来调用。因此在Finalize中只需要释放非托管资源即可。

解答问题2：

由于在Dispose()中已经释放了托管和非托管的资源，因此在对象被GC回收时再次调用Finalize是

没有必要的，所以在Dispose()中调用GC.SuppressFinalize(this)避免重复调用Finalize。

因此，上面的模式保证了：

　　1、 Finalize只释放非托管资源；

　　2、 Dispose释放托管和非托管资源；

　　3、 重复调用Finalize和Dispose是没有问题的；

　　4、 Finalize和Dispose共享相同的资源释放策略，因此他们之间也是没有冲突的。

在C#中，这个模式需要显式地实现，其中C#的~MyResource()函数代表了Finalize()。

优点：

1、如果客户没有调用Dispose(),未能及时释放托管和非托管资源,那么在垃圾回收时,还有机会执

行Finalize(),释放非托管资源,但是造成了非托管资源的未及时释放的空闲浪费。

2、如果客户调用了Dispose(),就能及时释放了托管和非托管资源,那么该对象被垃圾回收时,不回

执行Finalize(),提高了非托管资源的使用效率并提升了系统性能。

此外还有Close()方法，此方法一般和Open()方法配合来使用，对于数据库连接，一般可以逆向操作，比如打开->关闭，关闭->打开，而对于文件操作，一般是关闭文件，相当于Dispose()，而且有的用户更愿意使用Close()来释放资源，所以出现了一下这种相当于适配器模式的代码：

public void Close(){    Dispose(();}

最后还要再说一点，据MSDN上说C#不允许类实现Finalize()方法，所以用析构函数来代替。

记于此，勿忘。

2012.03.07 17:01