C# IDisposable的理解

C#里可以嵌入非托管代码，这就涉及到了这些代码资源的释放。以前总是看到别人的代码里那么写，也没有好好想想为什么，今天看了书，总结一下。

资源释放分为两种：

1. 托管的
2. 非托管的

两者的释放方式不一致：

1. 没有非托管资源的，GC在运行时，会自动回收和释放；
2. 含有非托管资源的，必须提供一个析构器，他们也会在内存里停留的时间会更长，最终被加入一个叫做finalization queue的结构，然后由GC在另一个线程释放；

实现IDispose接口是一种标准的释放资源的方式，正确使用会减少很多的bug和因为资源释放而引起的问题。正如上面所说，包含了非托管资源的代码，是必须提供一个析构器的。这样做的目的，是为了保证类的使用者，即使没有显式地调用Dispose方法，也可以正确地释放资源。

生产环境中的代码里，会有很多的继承，因此为了保证子类在调用时能够正确地执行父类的资源释放，在标准模式中，将真正的资源释放方法Dispose方法，抽象为一个virtual的方法，由子类去override，并在其中调用base的Dispose方法。

释放资源的Dispose方法，应该完成以下几件事（引用Effective C#）

1. 释放所有的非托管资源；
2. 释放所有的托管资源；
3. 设定一个标志，标志资源是否已经销毁；对于销毁的对象，仍旧调用，则应抛异常；
4. 跳过终结操作，调用GC.SuppressFinalize(this)方法。

以上，文字内容结束，基本的代码如下：

 using System;
 using System.Diagnostics;

 namespace Learn
 {
     class Program
     {
         private static int Cnt = ;

         static void Main(string[] args)
         {
             Stopwatch sw = new Stopwatch();
             sw.Start();
             for (int i = ; i < Cnt; i++)
             {
                 IDisposeDerived de = new IDisposeDerived();
             }
             sw.Stop();
             Console.WriteLine("total time is: " + sw.ElapsedMilliseconds);
             Console.ReadLine();
         }
     }

     internal class IDisposeBase : IDisposable
     {
         // never add this unless unmanaged resources exist
         // cauz this will add extra burdon and make negative influence on performance
         //~IDisposeBase()
         //{
         //    Dispose(false);
         //}

         private bool AlreadyDisposed = false;

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

         protected virtual void Dispose(bool shouldDisposeManagedReources)
         {
             if (AlreadyDisposed)
                 return;
             if (shouldDisposeManagedReources)
             {
                 // dispose the managed resources
                 // release the events
                 // etc.
             }
             // dispose the unmanaged resources

             // set the flag
             AlreadyDisposed = true;
         }

         public void MethodForPublic()
         {
             if (AlreadyDisposed)
                 throw new Exception("object has been disposed!");
             // do the normal things
         }
     }

     internal class IDisposeDerived : IDisposeBase
     {
         //~IDisposeDerived()
         //{
         //    Dispose(false);
         //}

         private bool AlreadyDisposed = false;

         protected override void Dispose(bool shouldDisposeManagedReources)
         {
             if (AlreadyDisposed)
                 return;
             if (shouldDisposeManagedReources)
             {
                 // dispose managed resources
             }
             // dispose unmanaged resources

             // call the base's dispose method
             base.Dispose(shouldDisposeManagedReources);

             // set the flag
             AlreadyDisposed = true;
         }
     }
 }

代码里增加了包含析构器的实现，可以对比一下，性能差异十分明显。

无析构器的实现结果：

有析构器的实现结果：