IDispose&finalize

呵呵，第一个问题有意思，没有这么做过。但有一点，不应该重写Finalize()函数。按照面向对象的原理来看，如果你重写了一个基类函数但没有使用override，它将隐藏基类中的函数，可能产生非预期的结果与冲突。   
    
  所以第二个问题实际上应该是不考虑重写Finalize()方法前提下如何妥善使用Dispose()和析构函数（这是一个比较常见的问题了）。回答如下：   
  （1）首先要明白一个原则：资源在哪个类中被创建就应该在哪个类中清理。如果类中调用了其他基类中创建的资源，则应在基类中删除这些资源。然后看以下内容。   
  （2）析构函数：   
  析构函数是由垃圾回收器在清理对象时调用的。   
  因为.NET中的托管对象都是由垃圾回收器自动定期清理的，所以如果一个类中只有托管对象，则垃圾回收器在回收该对象时会同时一次性清理掉该类中创建的托管对象，此种情况下不要编写析构函数（情况A)。   
  如果一个类中创建使用了非托管资源（如数据库连接）（情况B），此时应该使用析构函数，但也只是作为忘记调用Dispose()函数的一种备份机制。换言之，此时，应该先掉用Dispose()函数来删除资源。   
  （3）Dispose()函数：   
  Dispose()函数由用户来调用。   
  在上面的情况A中，可以不调用Dispose()函数。但如果类中创建使用过一些较大的托管对象，最好尽快清除它们，此时可以在Dispose函数中删除它们，并由用户调用以尽快删除它们。   
    
  在情况B中，应该在Dispose()中删除非托管资源，并由用户调用Dispose()。此时，为防止垃圾回收器再次调用析构函数，应该在Dispose()中调用GC.SuppressFinalize(this)通知垃圾回收器，此对象已经不再需要执行析构函数以免重复执行。但如果用户忘记了调用Dispose()，则垃圾回收器仍然会执行析构函数，保证非托管资源会被清除。   
    

  以上对析构函数和Dispose()用法说明参看下面代码：

  public   class   MyClass():IDisposable   
  {   
        private   StreamReader   sr;   
        private   int   connection;     
           
        public   void   Dispose()   
        {   
              Dispose(true);   
              GC.SuppressFinally(this);   
          }   
            
          protected   virtual   void   Dispose(bool   disposing)   
          {   
                  if(disposing)   
                  {     //清理托管资源   
                        if(sr!=null)   
                        {   
                              sr.Close();   
                              sr=null;   
                          }   
                  }   
                //清理非托管对象   
                  CloseConnection();   //假设类中有这样一个函数用于清理connection这个非托管资源   
            }   
    
            ~MyClass()   
            {   
                  Dispose(false);//仅仅清理非托管资源，除此外不应编写其它代码。   
              }     

-----------------

C# 中的Finalize 和Dispose(bool disposing)和 Dispose()

Finalize 和Dispose(bool disposing)和 Dispose() 的相同点:

这三者都是为了释放非托管资源服务的.

Finalize 和 Dispose() 和Dispose(bool disposing)的不同点:

1. Finalize是CRL提供的一个机制, 它保证如果一个类实现了Finalize方法,那么当该类对象被垃圾回收时,垃圾回收器会调用Finalize方法.而该类的开发者就必须在Finalize方法中处理 非托管资源的释放. 但是什么时候会调用Finalize由垃圾回收器决定,该类对象的使用者(客户)无法控制.从而无法及时释放掉宝贵的非托管资源.由于非托管资源是比较宝贵了,所以这样会降低性能.
2. Dispose(bool disposing)不是CRL提供的一个机制, 而仅仅是一个设计模式(作为一个IDisposable接口的方法),它的目的是让供类对象的使用者(客户)在使用完类对象后,可以及时手动调用非托管资源的释放,无需等到该类对象被垃圾回收那个时间点.这样类的开发者就只需把原先写在Finalize的释放非托管资源的代码,移植到Dispose(bool disposing)中.  而在Finalize中只要简单的调用 "Dispose(false)"(为什么传递false后面解释)就可以了.

这个时候我们可能比较疑惑,为什么还需要一个Dispose()方法?难道只有一个Dispose(bool disposing)或者只有一个Dispose()不可以吗? 
答案是:  
        只有一个Dispose()不可以. 为什么呢?因为如果只有一个Dispose()而没有Dispose(bool disposing)方法.那么在处理实现非托管资源释放的代码中无法判断该方法是客户调用的还是垃圾回收器通过Finalize调用的.无法实现 判断如果是客户手动调用,那么就不希望垃圾回收器再调用Finalize()(调用GC.SupperFinalize方法).另一个可能的原因(:我们知道如果是垃圾回收器通过Finalize调用的,那么在释放代码中我们可能还会引用其他一些托管对象,而此时这些托管对象可能已经被垃圾回收了, 这样会导致无法预知的执行结果(千万不要在Finalize中引用其他的托管对象). 

        所以确实需要一个bool disposing参数, 但是如果只有一个Dispose(bool disposing),那么对于客户来说,就有一个很滑稽要求,Dispose(false)已经被Finalize使用了,必须要求客户以Dispose(true)方式调用,但是谁又能保证客户不会以Dispose(false)方式调用呢?所以这里采用了一中设计模式:重载  把Dispose(bool disposing)实现为 protected, 而Dispose()实现为Public,那么这样就保证了客户只能调用Dispose()(内部调用Dispose(true)//说明是客户的直接调用),客户无法调用Dispose(bool disposing). 

范例如下:

public class BaseResource: IDisposable 
{ 
  //析构函数自动生成 Finalize 方法和对基类的 Finalize 方法的调用.默认情况下,一个类是没有析构函数的,也就是说,对象被垃圾回收时不会被调用Finalize方法 
  ~BaseResource()      
   { 
      // 为了保持代码的可读性性和可维护性,千万不要在这里写释放非托管资源的代码 
      // 必须以Dispose(false)方式调用,以false告诉Dispose(bool disposing)函数是从垃圾回收器在调用Finalize时调用的 
      Dispose(false); 
   } 
   
   
   // 无法被客户直接调用 
   // 如果 disposing 是 true, 那么这个方法是被客户直接调用的,那么托管的,和非托管的资源都可以释放 
   // 如果 disposing 是 false, 那么函数是从垃圾回收器在调用Finalize时调用的,此时不应当引用其他托管对象所以,只能释放非托管资源 
   protected virtual void Dispose(bool disposing) 
   { 
      
         // 那么这个方法是被客户直接调用的,那么托管的,和非托管的资源都可以释放 
         if(disposing) 
         { 
            // 释放 托管资源 
            OtherManagedObject.Dispose(); 
         } 
         
         
         //释放非托管资源 
         DoUnManagedObjectDispose(); 
         
                 
         // 那么这个方法是被客户直接调用的,告诉垃圾回收器从Finalization队列中清除自己,从而阻止垃圾回收器调用Finalize方法.         
         if(disposing)  
           GC.SuppressFinalize(this);   
           
   }  
   
   //可以被客户直接调用 
   public void Dispose() 
   { 
     //必须以Dispose(true)方式调用,以true告诉Dispose(bool disposing)函数是被客户直接调用的 
      Dispose(true);      
   } 
} 

上面的范例达到的目的: 

1/ 如果客户没有调用Dispose(),未能及时释放托管和非托管资源,那么在垃圾回收时,还有机会执行Finalize(),释放非托管资源,但是造成了非托管资源的未及时释放的空闲浪费

2/ 如果客户调用了Dispose(),就能及时释放了托管和非托管资源,那么该对象被垃圾回收时,不回执行Finalize(),提高了非托管资源的使用效率并提升了系统性能

可以参考SqlConnection对象的New, Open, Close(内部调用Dispose())的使用经历可以加深对他们的理解