博客园_徐磊

探索CLR原理系列(3):方法元数据和IL(适合老鸟,新人勿沉迷其中)

2011-10-31T01:24:00Z

前一篇我们探索了类型的第一种成员：字段。字段在IL编译时，会生成MdToken和偏移量，因为对于类型来说，一个类型在编译时就已经确定了字段的个数，所以偏移量对于编译器来说是已知的，字段和偏移量分别由元数据表(Field和ClassLayout)来记录。

本篇我们来讨论类型中的另一种成员:方法.在本系列的第一篇探索CLR原理系列(1):类型中我们说到类型中只有两种成员:字段和方法.字段是用来描述类型的状态,而方法则提供了类型所具备的功能.首先我们来看看方法在IL中是如何描述的.先来定义一个类型.

public class MethodClass
    {
        private string name="xulei";
        private int age=10;
        public static int Add(int a,ref int b) //静态
        {
            return a + b;
        }
        private static int Sub(out int a,out  int b) //私有静态
        {
            a = 10;
            b = 5;
            return a - b;
        }
        public void WriteName() //公有
        {
            Console.Write(name);
        }
        protected int GetAge()  //受保护
        {
            return age;
        }
        private void WriteNameAndAge() //私有
        {
            Console.Write(name + age.ToString());
        }

这个类型中我们定义了2个不同访问级别静态方法,3个不同访问级别的实例方法.下面我们来看看这些方法的元数据。

TypeDef #2 (02000003)
-------------------------------------------------------
    TypDefName: TestDemo1.Type.MethodClass  (02000003) //类型标识

    Method #1 (06000003) //方法标识
    -------------------------------------------------------
        MethodName: Add (06000003)
        Flags     : [Public] [Static]
        RVA       : 0x00002064
        ReturnType: I4
        2 Arguments //参数列表
            Argument #1: I4 //值传递
            Argument #2: ByRef  I4

//引用传递
        2 Parameters
            (1) ParamToken : (08000001) Name : a flags: [none]
            (2) ParamToken : (08000002) Name : b flags: [none]

    Method #2 (06000004)
    -------------------------------------------------------
        MethodName: Sub (06000004)
        Flags     : [Private] [Static]
        RVA       : 0x0000207c
        ReturnType: I4

这部分黄色的就是方法签名

2 Arguments
            Argument #1:ByRef   I4
            Argument #2:ByRef   I4
  2 Parameters 这部分是参数元数据表的内容
            (1) ParamToken : (08000003) Name : a flags: [out]
            (2) ParamToken : (08000004) Name : b flags: [out]

    Method #3 (06000005)
    -------------------------------------------------------
        MethodName: WriteName (06000005)
        Flags     : [Public]
        RVA       : 0x00002091
        hasThis 方法签名
        ReturnType: Void
        No arguments.

    Method #4 (06000006)
    -------------------------------------------------------
        MethodName: GetAge (06000006)
        Flags     : [Family]
        RVA       : 0x000020a0
        hasThis 方法签名
        ReturnType: I4
        No arguments.

    Method #5 (06000007)
    -------------------------------------------------------
        MethodName: WriteNameAndAge (06000007)
        Flags     : [Private]
        RVA       : 0x000020b8
        hasThis 方法签名
        ReturnType: Void
        No arguments.

可以看到在方法的原数据中包括了对方法的完整的描述,代码中高亮部分有二部分内容,方法返回值,方法参数.这二部分内容称之为方法签名,大家注意静态方法和实例方法有什么区别?仔细看一下,多了一个HasThis,关于原因我们在后面讨论.我们前一篇说过字段在Dll中有一个字段元数据表来描述所有的字段,那么方法也同样有一个方法的元数据表.来看看它是什么样子的.

方法的元数据表的Token是以0X06开头的,Token是IL中的标识数据,例如静态方法Add的标识为06000003,flags中标注了可见性,以及抽象,虚,静态,密封等方法的标记.Signature就是方法的签名，由返回值和参数组成。RVA是方法体在Dll文件中的相对地址，也就是方法的代码所在的相对地址。

除此之外，还有方法参数的起始位置.在类型那一篇中,我们讨论过类型中包含了字段起始位置,和方法的起始位置,那么这里的参数起始位置和前面二者的原理是相同的,用来查找方法的参数.来看看方法参数的元数据表吧

在上面的IL代码中Add方法的参数分别为一个值传递，一个引用传递，那么他们在IL中被标示为Byref，并且Out参数的Flags被标注为out，而Ref则与值传递参数的Flags没有任何区别，都为None，那么CLR在运行时如何判断呢？关键在于IL代码中，我们可以看到一个类似于C++中的去地址操作符&.

.method public hidebysig static int32 Add(int32 a,
int32& b)

这就是引用传递和值传递的区别了，Out参数也一样，只不过在参数原数据表中的Flags中标记了一个Out。那么参数原数据表中Flags的另一个标记Opt是什么意思呢？？呵呵，大家可以自己试验一下，定义一个可变参数 params int a 看看。

Sequence是什么意思？他代表参数的位置，也就是第几个参数。所以Sequence的值不能大于方法的参数个数。

也许大家会问，那么参数的类型呢，怎么不在参数元数据表中？这个秘密就是在方法的签名中。。。懂了吗？

总结

我们了解了方法是由元数据和IL代码组成。元数据中包括了方法的签名，方法的参数，以及参数的描述，IL代码中包含了方法的执行逻辑。每个方法在方法元数据表中都有一条记录，该记录包括方法在编译时的标识Token，以及方法的可见性，契约的特征Flags，还有方法的参数和返回值组成的签名，乃至引用了方法的每一个参数的特征，由参数元数据表来记录这些信息。

下一篇我们来聊聊方法在类型继承中的情况。。。

本文链接

[原创]探索CLR原理系列--索引贴

2011-10-12T03:16:00Z

　　本系列使用SOS来Debug示例代码,让我们一起看看自己编写的代码,编译后的程序集以及CLR运行时的真实面貌,从而更加深入的了解.net.本系列将围绕下面这张图,来和大家一起分享.net的真实世界.本人能力有限,难免会有理解错误的地方,欢迎大家指正.

由于某些媒体和个人喜欢拿来主义，所以笔者加了水印，见谅见谅。。。不影响大家看就是了，字比较小，可将浏览器放大。

探索CLR原理系列(1):类型

探索CLR原理系列(2):字段

探索CLR原理系列(3):方法元数据和IL

探索CLR原理系列(4):继承关系中的方法

探索CLR原理系列(5):方法表

探索CLR原理系列(6):接口虚表与方法偏移

探索CLR原理系列(7):特殊的方法-构造和析构

探索CLR原理系列(8):实例化

探索CLR原理系列(9):栈中有什么

探索CLR原理系列(10):装箱和拆箱

探索CLR原理系列(11):垃圾回收和析构

探索CLR原理系列(12):线程栈和应用程序域

探索CLR原理系列(13):反射

由于各部分之间的相关性比较复杂,所以目录有可能会改变.

本文链接

[原创]探索CLR原理系列(2):字段在内存中的布局 (适合老鸟,新人勿沉迷其中)

2011-10-08T01:24:00Z

上一篇文章我们探索了类型,每一个类型在元数据的Typedef表中,会分配一个MdToken(类型标记),当你写的方法需要访问这个类型时,也是使用MdToken到相关Dll的元数据表去加载它到Load Heap,LoadHeap是用来存放类型的空间,它并不保存类型的实例.我们可以为类型定义一系列成员,包括:字段,属性,方法,事件和嵌套类,但我们跟踪类型的EEclass,发现类型中只有两类成员,字段(事件就是一个委托,而委托只是一个类型,所以事件就是一个字段而已,但表现有些特殊后续介绍)和方法(属性实际就是方法).

这篇文章就让我们一起来探索类型中很重要的一部分:字段.首先来说明一下为什么类型需要字段?

在面向对象的语言中,每一个类型或者实例化的对象都代表一个可以解决某种特定问题的实体.那么这些实体就会有描述自身当前状态的需要,如何满足这种需要呢?

类型的状态我们使用静态字段来描述,实例的状态我们使用实例字段来表述,还有一部分状态我们需要它是不可变的(常量字段).那么这三类字段在IL中如何表现,CLR有如何加载分配内存呢,下面我们一起来扒一扒字段的隐私.

我们来定义一个类型,这个类型中包括静态字段,实例字段和常量字段.这里我们只讨论字段,所以不考虑封装性.

    public class TestObjectType1
    {
        public static int SX;
        public object X;

public const double CX=10;

public readonly string RX;

}

我们来看看IL中是如何表示的.

TypeDef #2 (02000003) //上篇文章提到的类型标识.
-------------------------------------------------------
    TypDefName: TestDemo1.Type.TestObjectType1  (02000003)
    Flags     : [Public] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit]  (00100001)
    Extends   : 01000001 [TypeRef] System.Object

    Field #1 (04000001) //常量字段标识
    -------------------------------------------------------
        Field Name: CX (04000001)
        Flags     : [Public] [Static] [Literal]//注意这个词 [HasDefault]  (00008056)
     DefltValue: (R8) 10  //注意值被直接写到这里,常量就是静态的
        Field type:  R8 //字段类型double在IL中的表示

    Field #2 (04000002)//静态字段标识
    -------------------------------------------------------
        Field Name: SX (04000002)
        Flags     : [Public] [Static]  (00000016)
        Field type:  I4  //字段类型，int32在IL中的表示

    Field #3 (04000003) //实例字段

标识.
    -------------------------------------------------------
        Field Name: X (04000003)
        Flags     : [Public]  (00000006)
        Field type:  Object//字段类型

Field #4 (04000004)

-------------------------------------------------------

Field Name: RX (04000004)

Flags : [Public] [InitOnly] (00000026) //只能在初始化时赋值

CallCnvntn: [FIELD]

Field type: String

根据上面的IL,我们看到字段也有它的0400000X标识,实例字段和静态字段只有一点不同,就是[Static]关键字.而常量也是静态字段,但是与普通静态字段相比还多了[HasDefault],代表它有默认值.[Literal]说明在CLR布局类型内存时,不包含此字段.

那么CLR如何在加载一个类型的时候，侦测到类型中的字段呢？

上一篇我们提到了TypeDef元数据表，表中有一个字段是FieldList(参见上一篇探索CLR原理(1)-类型)，这个字段会指向一个Field元数据表中，该类型所定义的字段的起始位置，也就是说每个类型定义的字段不管是静态还是动态在元数据表中是连续的。该元数据表以字段的标识做为索引。

我们来看看在CLR中一个类型的静态字段和实例字段在内存中是怎样的。CLR如何访问一个字段？先来编写一段C#代码：

TestObjectType1 t = new TestObjectType1();

t.X = new object(); //给实例字段赋值

TestObjectType1.SX = 20; //给静态字段赋值

double b = TestObjectType1.CX; //给常量赋值

看看IL中如何表现这段代码

    //初始化一个object
  IL_0008:  newobj     instance void [mscorlib/*23000001*/]System.Object/*01000001*/::.ctor() /* 0A000011 */

    //为实例字段X赋值
  IL_000d:  stfld      object TestDemo1.Type.TestObjectType1/*02000003*/::X /* 04000003 */
    //将20推送入栈
  IL_0012:  ldc.i4.s   20
    //为静态字段赋值
  IL_0014:  stsfld     int32 TestDemo1.Type.TestObjectType1/*02000003*/::SX /* 04000002 */
    //加载常量
  IL_0019:  ldc.r8     10. //注意这里，并没有使用任何标识，而是直接将10放到了IL中

我们在上一篇说到，CLR加载一个类型，是通过类型元数据中的标识在TypeDef的元数据表中查找类型，在加载类型的时候一定需要加载字段，不管是静态还是实例的字段，参见上一篇，开篇时的那幅图。为什么实例字段也需要加载到类型上，实例字段不是属于对象吗？原因是当你的类型被实例化的时候，需要一份已有的实例字段的描述，来布局你的实例的内存。这样讲好象不太容易理解，咱们先用SOS来看看上面代码中实例化的TestObjectType1到底是个什么鸟样？

TestObjectType1 t = new TestObjectType1();

t.X = new object(); //给实例字段赋值

TestObjectType1.SX = 20;  //给静态字段赋值调试当前点

double b = TestObjectType1.CX; //获取常量

!dumpobj 0x022bb928
Name:        TestDemo1.Type.TestObjectType1
MethodTable: 001838e8
EEClass:     00181518
Size:        12(0xc) bytes
File:        D:\History\Test\ConsoleApplication1\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
68e1f568  4000003        4        System.Object  0 instance 022bb934 X //可以看到Object被赋值了

68e228f8 4000002 24 System.Int32 1 static 0 SX

通过上面的调试信息，我们发现二个问题，第一：Offset，第二竟然没有常量的信息！！

首先我们先来看Offset(偏移量),我们先不管这个偏移量是相对于哪个内存地址的偏移。实例字段X的偏移量是4，一个引用类型的指针所占的大小是4，那么静态字段的偏移量应该是8，可是这里竟然是24，为什么？

为了察看以上信息，笔者不得不更换代码的实现。因为SOS调试信息有些东西看不到。重新定义代码

//类型定义
public class TestObjectType1
{
public static int SX= 10;
public int X= 20；

}

//主函数
TestObjectType1 t = new TestObjectType1()；

Test(ref t.X);

Test(ref TestObjectType1.SX); //使用地址传递，以拿到地址

Test()方法只是使用地址传递来拿到静态变量的地址,再次启动SOS调试。

0019ebf4 00340109 TestDemo1.Type.TestMain.Main()
    LOCALS:
0x0019ebf8 = 0x0255b928 //t实例的地址

0019ebb0 003401c4 TestDemo1.Type.TestMain.Test(Int32 ByRef)

    PARAMETERS:
        x (0x0019ebb0) = 0x0255b92c //t.X的地址
!
0019ebb0 003401c4 TestDemo1.Type.TestMain.Test(Int32 ByRef)
    PARAMETERS:
        x (0x0019ebb0) = 0x001d391c //TestObjectType1.SX的地址

!dumpobj 0x0255b928
Name:        TestDemo1.Type.TestObjectType1
MethodTable: 001d38f8
EEClass:     001d151c
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
68e228f8  4000002        4         System.Int32  1 instance        0 X
68e228f8  4000001       24         System.Int32  1   static       10 SX

Vtable Slots: 4
Total Method Slots: 6

注意图中以相同颜色标注的两对地址，首先看蓝色的。他们的地址相差4，与Offset4相等，说明实例字段的Offset是指和实例的指针的偏移量。

那么黄色的偏移量是多少呢？呵呵，答案一定是24了，如果你再定义一个静态字段(引用类型)那么肯定就是28了，大家可以试试。为什么偏移量是24呢？

注意灰色的部分，原来静态字段是放在方法表后面的。。。

可能很多人会问，这里的测试代码为什么不用引用类型，因为引用类型用地址获取时，是引用类型实例所在的地址，静态变量只是引用了这个地址。笔者也想通过内存来分析这个引用类型，可是笔者实在不知道那内存中显示的16进制的垃圾数字，到底是啥意思。见谅！！

关于值类型的字段，其实和引用类型一样，也是有一个FieldDes来描述所有的字段，当CLR加载类型时，也会将这部分内容加载进去，大致上就是字段类型和偏移地址。元数据是不加载到CLR中的，最多就是一个MdToken的标识，和前一篇说到类型时一样。今天说到的内存结构如下图(前一篇图的部分内容)，图中标黄的部分。

那么偏移地址是怎样生成的呢？答案是IL编译时，在DLL的元数据表中还有一个表叫做ClassLayout，表中定义了相应字段的偏移地址，以上面提到的Field元数据表中，字段的标识做索引。

那么CLR如何访问字段，使通过MdToken吗？我们来看看方法执行时的汇编，就一目了然了。

TestObjectType1 t = new TestObjectType1();
t.X = 20;

004D0106 8945C4           mov         dword ptr [ebp-3Ch],eax //取得当前对象
004D0109 8B45C4           mov         eax,dword ptr [ebp-3Ch]
004D010C C7400414000000   mov         dword ptr [eax+4],14h //将当前对象 +4 的偏移地址处存储20;

原来在方法执行时，使用的都是偏移地址(除反射动态查找字段以外).

字段在继承时会怎样？

有很多人并不是很清楚继承时字段是怎样的，比如静态字段能不能继承？下面我们专门来讨论一下这个问题。有类如下：

  public class TestObjectType1
    {
        public static int SX = 10;

        private int PX;

        protected int X;
    }

    public class TestObjectType2 : TestObjectType1
    {}

我们来看看IL是怎样的。TestObjectType1在这里笔者就不列出来了，主要看它的派生类。

TypeDef #3 (02000004)
-------------------------------------------------------
    TypDefName: TestDemo1.Type.TestObjectType2  (02000004)
    Flags     : [Public] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit]  (00100001)
    Extends   : 02000003 [TypeDef] TestDemo1.Type.TestObjectType1

我们发现在TestObjectType2中没有任何字段定义，这是为什么？为了搞明白原因，我们再次使用SOS来察看。

!dumpobj 0x0260b928
Name:        TestDemo1.Type.TestObjectType1 //父类型
MethodTable: 00303914 //自己的方法表
EEClass:     00301538
Fields: //自己的字段表
      MT    Field   Offset                 Type VT     Attr    Value Name
6a7128f8  4000002        4         System.Int32  1 instance        0 PX
6a7128f8  4000003        8         System.Int32  1 instance        0 X
6a7128f8  4000001       24         System.Int32  1   static       10 SX

!dumpobj 0x0260b938
Name:        TestDemo1.Type.TestObjectType2
MethodTable: 00303980

//自己的方法表
EEClass: 003015a4
Fields:

//自己的字段表
      MT    Field   Offset                 Type VT     Attr    Value Name
6a7128f8  4000002        4         System.Int32  1 instance        0 PX //私有字段也被继承。
6a7128f8  4000003        8         System.Int32  1 instance        0 X
6a7128f8  4000001       24         System.Int32  1   static       10 SX

这里为了证明子类和父类不是使用同一个字段，我们做一下测试：

TestObjectType1 t1 = new TestObjectType1();

TestObjectType2 t2 = new TestObjectType2();

Test(ref TestObjectType1.SX);
Test(ref TestObjectType2.SX);

再次使用SOS，看看两个静态变量是否指向相同地址。

002eeda8 00520224 TestDemo1.Type.TestMain.Test(Int32 ByRef)

    PARAMETERS:
        x (0x002eeda8) = 0x003033b8

002eeda8 00520224 TestDemo1.Type.TestMain.Test(Int32 ByRef)
    PARAMETERS:

x (0x002eeda8) = 0x003033b8

结果是什么呢？原来静态变量的继承时逻辑上的，也就是说物理上来讲父类和子类，共享共有的静态字段。

那么实例变量呢？肯定是不共享的，大家可以自己做测试。

总结：

本篇我们探索了类型的第一种成员：字段。字段在IL编译时，会生成MdToken和偏移量，因为对于类型来说，一个类型在编译时就已经确定了字段的个数，所以偏移量对于编译器来说是已知的，字段和偏移量分别由元数据表(Field和ClassLayout)来记录。

在类型的CLR内存布局中，有一个FieldDesList，它指向类型的字段描述(主要是字段签名和偏移量).当CLR首次加载类型时，会根据元数据表来生成 FieldDesList，包括实例和静态字段，其中静态字段的偏移量是相对于方法表中最后一项方法地址而言，所以静态字段在类型方法列表的后面进行布局，也就是说你的静态字段就存储在这个空间,它是属于类型的,也就是说所有这个类型的实例共享这个静态字段。而实例字段则是和实例在一起，属于每一个实例,它的偏移量是以实例的类型指针为基址而计算的。

子类从父类派生时,所有字段全部被派生,与可访问性无关,但对于静态字段来说,子类和父类都指向相同地址,即逻辑继承,物理上则共享.

下一篇将于大家一起探讨关于类型的另一个成员：方法，内容将会非常多，也是CLR中比较复杂的设计之一.关于实例的部分，笔者将单独分出一篇来和大家一起讨论，届时我们将分析实例的生成(GC堆和栈),以及实例的销毁(垃圾回收和栈资源的释放).

本文链接

[原创]探索CLR原理系列(1):类型 (适合老鸟,新人勿沉迷其中)

2011-09-19T01:26:00Z

CLR是整个Dotnet的灵魂,CIL则是这个灵魂可以发挥其跨越平台,穿越语言,跳跃....的保证.其实有很多书籍和文章都介绍了什么是CLR,什么是CIL,CTS,CLS这样的一大堆概念,可是他们具体的表现形式,以及运作的原理是大部分人都想知道的秘密,却没有什么太好的途径来获取这些信息.本系列将从C#代码->CIL->CLR来探索我们编写的C#代码,最终如何成为本地机器语言,并且执行.过程中会使用VS2010+SOS调试.关于SOS调试的详细内容,大家可以上网搜索,这里不再赘述.

一直想写这个系列的文章,可是内容太多,其中各部分之间的相关性很复杂,让我感觉无从下手.终于决定先硬着头皮写一篇看看,否则可能永远也不知道该从哪里些起.文章中的内容都是笔者大量的阅读书籍以及从网络搜索资料加上自己的试验,调试所理解到的东西,笔者能力有限,如有误导观众之处,欢迎大家指出.我们可以一起讨论,一起来完善这些知识.

先给大家一个图，笔者吐血画出来的，可以先看看Load堆中类型大致是一个怎么样的状态。图中的其他内容，笔者将陆续介绍给大家,这个图只是其中的一部分,还有线程栈的部分,由于图太大,等说到那部分再发吧.图中的MatedataToken就是我们今天介绍的从IL到CLR，类型的标记的一部分,即TestObjectType1的类型标记码（2000003）。

由于某些媒体和个人喜欢拿来主义，所以笔者加了水印，见谅见谅。。。不影响大家看就是了，字比较小，可将浏览器放大。

今天先来说说.net中的类型,我们先不去区分什么值类型在声明它的地方,引用类型类型的实例在GC堆中.实际在CLR中有3个堆(GC堆，Load堆，大对象堆）,我们今天要描述的是Load堆用来存放类型而不是类型的实例，关于GC堆是后面要做的事情.只说类型,首先看一下笔者定义的类型.

1 public class TestObjectType1

2     { }
3
4     public struct TestValueType1
5     { }
6
7     public interface ITestInterface1
8     { }
9
10     public delegate void TestDelegate1();

在这里我只定义了类型,类型中没有任何成员,下面我将编译生成程序集,然后来看看CIL中他们是什么样子.

首先来看看引用类型TestObjectType1

1 TypeDef #1 (02000002) //类型标记码

2 -------------------------------------------------------
3     TypDefName: TestDemo1.Type.TestObjectType1  (02000003)
4     Flags     : [Public] [AutoLayout]//类型字段加载方式 [Class] [AnsiClass] [BeforeFieldInit]
5     Extends   : 01000001 [TypeRef] System.Object //父类
6
7 TypeRef #1 (01000001)
8 -------------------------------------------------------
9 Token:             0x01000001
10 ResolutionScope:   0x23000001
11 TypeRefName:       System.Object

可以看到在CIL的元数据部分,可以清晰地看到TestObjectType1继承自Object以及它的类型内存布局,这是CLR用来区分如何分配实例的内存的关键.还有类型标记(反射和JIT编译时会使用类型标记来快速的查找类型).

下面来看看Struct和Class有什么不同?

1 TypeDef #2 (02000004) 类型标记码
2 -------------------------------------------------------
3     TypDefName: TestDemo1.Type.TestValueType1  (02000004)
4     Flags     : [Public] [SequentialLayout] //类型字段加载方式  [Class] [Sealed] [AnsiClass] [BeforeFieldInit]
5     Extends   : 01000002 [TypeRef] System.ValueType
6     Layout    : Packing:0, Size:1
7
8 TypeRef #2 (01000002)
9 -------------------------------------------------------
10 Token:             0x01000002
11 ResolutionScope:   0x23000001

12 TypeRefName: System.ValueType

值类型都继承自ValueType,当然ValueType也最终继承自Object,在这里大家可以看到它的Flags中也是Class,而且还是Sealed.还有一个需要注意的是Layout中,它的Size竟然是1,我们并没有定义任何的成员阿?这里的1笔者将会在后面给出答案.

我们再来看看接口有什么不同

1 TypeDef #3 (02000005)//类型标记码
2 -------------------------------------------------------
3 TypDefName: TestDemo1.Type.ITestInterface1 (02000005)
4 Flags : [Public] [AutoLayout] [Interface] [Abstract] [AnsiClass]

5 Extends : 01000000 [TypeRef] //父类不存在

可以看到接口不存在任何父类,它只是一个纯抽象的契约而已,很多书上都说任何类型都最终继承自Object是不严谨的.那么为什么接口不继承自Object呢,简单来说由于Object已实现的方法,如果接口继承自它,那么接口也就有了这些虚方法和受保护的方法,虚方法可以重写,那么就破坏了接口做为契约的本质.在实现了接口的所有类型的方法表中,将开辟两个Tostring,两个GetHashcode等的方法槽造成你调用方法时产生二义性,并且还会大量的占用内存(虽然一个方法槽只有4个字节,但是架不住类型多).你或许会说两个方法槽最终可以指向同一个方法地址,Ok.这样说两个相同的方法有同一种实现,即占用了内存,还什么用都没有,为什么要这样做呢?

OK,讨论完接口我们来看看委托,这里我们只是为了解一下委托的类型,关于委托笔者会单独写一篇文章来探索它.

1 TypeDef #4 (02000006)//类型标记码
2 -------------------------------------------------------
3     TypDefName: TestDemo1.Type.TestDelegate1  (02000006)
4     Flags     : [Public] [AutoLayout] [Class] [Sealed] [AnsiClass]
5     Extends   : 01000003 [TypeRef] System.MulticastDelegate //父类

委托在实际就是一个类,继承自(MulticastDelegate,它又继承自Delegate,而最终也是Object的孩子),并且和值类型一样都是Sealed.表示它们不可以被继承,至于为什么不可以被继承,笔者将会在后续的文章中介绍. 我们在这里讨论了Class,Interface,struct,Delegete 发现他们的类型标记都是0200000X,都是用TypeDef来定义类型,用TypeRef来表述父类,并且有足够的信息来描述你写的C#代码.而且除了Interface,全部都被定义为Class.那么当CLR来加载这些元数据时,靠什么来区分你所定义的Struct和Class呢?CLR如何快速去查找类型呢?

dll中的数据到底是什么样子的,当CLR加载一个DLL乃至加载一个类型到物理内存的时候如何查找类型?

在编译好的dll中,实际上是由很多张表,以及一些特定的string堆,Guid堆,BLOB堆来组成的元数据,我们先来看看TypeDef表.你所定义的类型都被放在TypeDef表中,这个表你可以想象成如同二维的数据库表一样,有Token类型标记码作为主键,还可以查找到它的父类(Extends)的类型标记码.以及类型到底是Class,Valuetype,Interface(图中Flags的注释中的C，I，V)前两个是根据他们的父类来识别,而Interface有关键字来表示,参照上面的元数据.

我们现在来看看CLR如何加载一个类型.

1        TestObjectType1 obj = new TestObjectType1();
2
3   TestValueType1 val = new TestValueType1();

如何使用设计模式来构造系统(索引贴)

2008-08-25T03:13:00Z

一直很想写关于设计模式的具体使用的文章,可是一直没想好怎么去写,才可以通俗易懂,真正的让设计模式,应用到系统设计中.今天终于想到了,这个系列准备用实例去讲解如何使用(GOF)设计模式.

如何使用设计模式来构造系统--(9)

2008-08-22T01:39:00Z

前面的客户端程序中,遍历部门时,有个对部门还是人员的判断,然后按照不同的类型输出不同的结果,这样增加了客户端的复杂度,如果出现另一种情况,那么就要修改客户端,因为客户端程序大部分都不是出现在一个调用中,所以这样的修改十分可怕,如果输出有所变化,比如多加几个字,或者显示员工福利工资,那么就不得不修改客户代码所有出现的输出的地方.那么我们如何来封装这个变化呢?

如何使用设计模式来构造系统--(8)

2008-08-21T01:03:00Z

前面我们完成了复杂的Composite的创建的封装,但是那里面还有缺点:前面我们说了一个人可能身兼二职,尤其管理层的,更有这个可能,那么他就要出现在不同部门里,而我们现在的创建是一个节点一个对象,这样我们就要浪费内存了...怎么解决?

如何使用设计模式来构造系统--(7)

2008-08-20T06:52:00Z

在前面的文章中,我们设计完成了员工工资,福利以及按照部门来区分员工,以及遍历统计部门人员成本等业务逻辑,这些设计基本上可以满足我们所设定的场景的变化,可是创建部门及人员树的时候太复杂了,而且这种创建很容易发生变化,比如加入分公司,或者部门层级变动添加了层级的时候,创建的代码一定就要修改.那么如何避免,封装这个创建时的变化呢?

如何使用设计模式来构造系统--(6)

2008-08-19T04:10:00Z

前面我们设计完成了统计部门工资,这样的一个需求,但是在我们设计遍历员工信息的方法是固定不变的,也就是说是硬编码在PersonComposite类中的,由于Composite设计模式相当于一个树或者图的数据结构,那么他的遍历就会出现变化,比如在遍历部门和小组的时候采取不同的方法,以减少遍历的时间,那么如何去解决这个问题呢?

如何使用设计模式来构造系统--(5)

2008-08-15T06:47:00Z

前面我们设计了员工的工资，奖金，福利系统。今天客户又来增加需求了:"我们需要统计公司，部门，或者小组的薪资成本。"得到了需求，我们还是按照老套路来完成我们的设计。

博客园_徐 磊

探索CLR原理系列(3):方法元数据和IL(适合老鸟,新人勿沉迷其中)

[原创]探索CLR原理系列--索引贴

[原创]探索CLR原理系列(2):字段在内存中的布局 (适合老鸟,新人勿沉迷其中)

[原创]探索CLR原理系列(1):类型 (适合老鸟,新人勿沉迷其中)

如何使用设计模式来构造系统(索引贴)

如何使用设计模式来构造系统--(9)

如何使用设计模式来构造系统--(8)

如何使用设计模式来构造系统--(7)

如何使用设计模式来构造系统--(6)

如何使用设计模式来构造系统--(5)

博客园_徐磊