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 = 100000;

        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; 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;
        }
    }
}

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

无析构器的实现结果：

有析构器的实现结果：