首先来看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);
}
}
}
}