证明析构函数隐式转换为vitual的finalize方法

我们自己写一个非常简单的类，如下所示：

using System;

using System.Collections.Generic;

using System.Text;

 

namespace DestructPractise

{

    class TestDestructor

    {

        static void Main(string[] args)

        {

        }

 

        ~TestDestructor()

        {

            System.Console.WriteLine("i am destructor");

        }

    }

}

我们自己显式的定义析构函数，并在里面加了一句话。

编译为exe文件。

使用Reflector反编译之：

.class private auto ansi beforefieldinit TestDestructor
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
    {
        .maxstack 8
        L_0000: ldarg.0
        L_0001: call instance void [mscorlib]System.Object::.ctor()
        L_0006: ret
    }

    .method family hidebysig virtual instance void Finalize() cil managed
    {
        .maxstack 1
        L_0000: nop
        L_0001: ldstr "i am destructor"
        L_0006: call void [mscorlib]System.Console::WriteLine(string)
        L_000b: nop
        L_000c: nop
        L_000d: leave.s L_0017
        L_000f: ldarg.0
        L_0010: call instance void [mscorlib]System.Object::Finalize()
        L_0015: nop
        L_0016: endfinally
        L_0017: nop
        L_0018: ret
        .try L_0000 to L_000f finally handler L_000f to L_0017
    }

    .method private hidebysig static void Main(string[] args) cil managed
    {
        .entrypoint
        .maxstack 8
        L_0000: nop
        L_0001: ret
    }

}
从IL语言中可看出来：

1）我们在上面的代码中没有定义构造函数，CLR自动给我们加了一个默认构造函数。

       可以看出来实际上是使用object的构造器构造了一个object，然后丢出去了。

2）析构函数确实隐式的转换成了vitual的Finalize()。

       在隐式转换成的Finalize()方法中，L_0000到L_000f之间都是处理我们之前写在析构函数中的东西。

       注意观察，在L_000f到L_0017之间又调用了它父类，即Object的Finalize()。

       所以析构函数等价与：

      protected vitual void Finalize()

      {

             try

             {

                       //析构函数中原来写的东西

             }

            finally

             {

                    base.Finalize();

             }

      }