.NET中IDisposable接口的基本使用（关于内存泄露）

首先来看MSDN中关于这个接口的说明：

[ComVisible(true)]
public interface IDisposable
{
    // Methods
    void Dispose();
}
1.[ComVisible(true)]：指示该托管类型对 COM 是可见的.
2.此接口的主要用途是释放非托管资源。当不再使用托管对象时，垃圾回收器会自动释放分配给该对象的内存。但无法预测进行垃圾回收的时间。另外，垃圾回收 器对窗口句柄或打开的文件和流等非托管资源一无所知。将此接口的Dispose方法与垃圾回收器一起使用来显式释放非托管资源。当不再需要对象时，对象的 使用者可以调用此方法。

一：基本应用

1.我们来定义一个实现了IDisposable接口的类，代码如下：

public class CaryClass :IDisposable
{
    public void DoSomething()
    {
       Console.WriteLine("Do some thing....");
    }
    public void Dispose()
    {
       Console.WriteLine("及时释放资源");
    }
}
2.我们有两种方式来调用：
2.1.第一种方式，使用Using语句会自动调用Dispose方法，代码如下：
  using (CaryClass caryClass = new CaryClass())
  {
      caryClass.DoSomething();
  }
2.2第二种方式，现实调用该接口的Dispose方法，代码如下：
  CaryClass caryClass = new CaryClass();
   try
    {
       caryClass.DoSomething();               
    }
   finally
    {
       IDisposable disposable = caryClass as IDisposable;
       if (disposable != null) disposable.Dispose();
    }
两种方式的执行结果是一样的，如下图：

2.3.使用try/finally 块比使用 using 块的好处是即使using中的代码引发异常，CaryClass的Dispose方法仍有机
会清理该对象。所以从这里看还是使用try/catch好一些。

二：Disposable 模式
1.在.NET种由于当对象变为不可访问后将自动调用Finalize方法，所以我们手动调用IDisposable接口的Dispose方法
和对象终结器调用的方法极其类似，我们最好将他们放到一起来处理。我们首先想到的是重写Finalize方法，如下：
protected override void Finalize()
{
     Console.WritleLine("析构函数执行...");
}
当我们编译这段代码的时候，我们发现编译器会报如下的错误：

这是因为编译器彻底屏蔽了父类的Finalize方法，编译器提示我们如果要重写Finalize方法我们要提供一个析构函数来
代替，下面我们就提供一个析构函数：
  ~CaryClass()
  {
      Console.WriteLine("析构函数执行...");
  }
实际上这个析构函数编译器会将其转变为如下代码：
protected override void Finalize()
{
   try
   {
     Console.WritleLine("析构函数执行...");
   }
   finally
   {
     base.Finalize();
   }
}
2.然后我们就可以将Dispose方法的调用和对象的终结器放在一起来处理，如下：
public class CaryClass: IDisposable
{
    ~CaryClass()
    {
        Dispose();
    }
    public void Dispose()
    {
        // 清理资源
    }
}
3.上面实现方式实际上调用了Dispose方法和Finalize方法，这样就有可能导致做重复的清理工作，所以就有了下面经典
Disposable 模式：
private bool IsDisposed=false;  
public void Dispose()  
{  
     Dispose(true);  
     GC.SupressFinalize(this);  
}  
protected void Dispose(bool Diposing)  
{  
     if(!IsDisposed)  
     {  
         if(Disposing)  
         {  
            //清理托管资源
         }  
         //清理非托管资源
     }  
     IsDisposed=true;  
}  
~CaryClass()  
{  
     Dispose(false);  
}
3.1. SupressFinalize方法以防止垃圾回收器对不需要终止的对象调用 Object.Finalize（）。
3.2. 使用IDisposable.Dispose 方法，用户可以在可将对象作为垃圾回收之前随时释放资源。如果调用了 IDisposable.Dispose 方法，此方法会释放对象的资源。这样，就没有必要进行终止。IDisposable.Dispose 应调用 GC.SuppressFinalize 以使垃圾回收器不调用对象的终结器。
3.3.我们不希望Dispose(bool Diposing)方法被外部调用，所以他的访问级别为protected 。如果Diposing为true则释放托管资源和非托管资源，如果 Diposing等于false则该方法已由运行库从终结器内部调用，并且只能释放非托管资源。
3.4.如果在对象被释放后调用其他方法，则可能会引发 ObjectDisposedException。

三：实例解析

1.下面代码对Dispose方法做了封装，说明如何在使用托管和本机资源的类中实现 Dispose(bool) 的常规示例：
public class BaseResource : IDisposable
    {
        // 非托管资源
        private IntPtr handle;
        //托管资源
        private Component Components;
        // Dispose是否被调用
        private bool disposed = false;

        public BaseResource()
        {            
        }
      
        public void Dispose()
        {
            Dispose(true);            
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
           
            if (!this.disposed)         
            {               
                if (disposing)
                {
                    // 释放托管资源
                    Components.Dispose();
                }
                // 释放非托管资源，如果disposing为false,
                // 只有托管资源被释放
                CloseHandle(handle);
                handle = IntPtr.Zero;
                // 注意这里不是线程安全的
            }
            disposed = true;
        }

        // 析构函数只会在我们没有直接调用Dispose方法的时候调用
        // 派生类中不用在次提供析构函数
        ~BaseResource()
        {
            Dispose(false);
        }

        // 如果你已经调用了Dispose方法后在调用其他方法会抛出ObjectDisposedException
        public void DoSomething()
        {
            if (this.disposed)
            {
                throw new ObjectDisposedException();
            }
        }
    }

   
    public class MyResourceWrapper : BaseResource
    {
        // 托管资源
        private ManagedResource addedManaged;
        // 非托管资源
        private NativeResource addedNative;
        private bool disposed = false;
      
        public MyResourceWrapper()
        {           
        }

        protected override void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                try
                {
                    if (disposing)
                    {                        
                        addedManaged.Dispose();
                    }
                    
                    CloseHandle(addedNative);
                    this.disposed = true;
                }
                finally
                {                  
                    base.Dispose(disposing);
                }
            }
        }
    }
2.使用CLR垃圾收集器，您不必再担心如何管理对托管堆分配的内存，不过您仍需清理其他类型的资源。托管类通过
IDisposable 接口使其使用方可以在垃圾收集器终结对象前释放可能很重要的资源。通过遵循 disposable 模式并且留
意需注意的问题，类可以确保其所有资源得以正确清理，并且在直接通过 Dispose 调用或通过终结器线程运行清理代码时
不会发生任何问题。

IDisposable接口定义了一个模式,为释未托管资源提供了确定的机制,并避免产生析构函数固有的与GC相关的问题.

这种手动释放资源的方式肯定要比等待GC来回收要效率高啊,于是出现了下面的示例类代码:
   
    这个Foo类实现了IDisposable接口,里面有一个简单的方法:增加一个用户.

Code
public class Foo : IDisposable
    {
        /**//// <summary>
        /// 实现IDisposable接口
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            //.NET Framework 类库
            // GC..::.SuppressFinalize 方法
            //请求系统不要调用指定对象的终结器。
            GC.SuppressFinalize(this);
        }
        /**//// <summary>
        /// 虚方法，可供子类重写
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!m_disposed)
            {
                if (disposing)
                {
                    // Release managed resources
                }

                // Release unmanaged resources

                m_disposed = true;
            }
        }
        /**//// <summary>
        /// 析构函数
        /// 当客户端没有显示调用Dispose()时由GC完成资源回收功能
        /// </summary>
        ~Foo()
        {
            Dispose(false);
        }
        /**//// <summary>
        /// 增加一个用户
        /// </summary>
        public bool  AddUser()
        {
            //代码省略
            return true;
        
        }
        /**//// <summary>
        /// 是否已经被释放过,默认是false
        /// </summary>
        public  bool m_disposed;
        //private IntPtr handle;

    }


      客户端是这样调用的:先实例化对象,然后增加一个用户,此时销毁对象.