Delphi 的RTTI机制浅探

转http://blog.sina.com.cn/s/blog_53d1e9210100ukdt.html

目 录
===============================================================================
⊙ DFM 文件与持续机制(persistent)
⊙ ReadComponentResFile / WriteComponentResFile 函数
⊙ Delphi 持续机制框架简述
⊙ 一个 TForm 对象的创建过程
⊙ TStream Class 和 TStream.ReadComponent 方法
⊙ TReader Class 和 TReader.ReadRootComponent 方法
⊙ TReader.ReadPrefix 方法
⊙ TComponent.ReadState 虚方法
⊙ TReader.ReadData 方法
⊙ TReader.ReadDataInner 方法
⊙ TReader.ReadProperty 方法
⊙ TPersistent.DefineProperties 虚方法
⊙ TReader.ReadComponent 方法
⊙ TReader.ReadValue / TReader.NextValue 系列方法
⊙ TReader.ReadStr 方法
⊙ TReader.ReadInteger / ReadString / ReadBoolean 系列方法
⊙ TReader.Read 方法
⊙ ObjectBinaryToText / ObjectTextToBinary 函数



正 文
===============================================================================
⊙ DFM 文件与持续机制(persistent)
===============================================================================
我们在使用 Delphi 的 IDE进行快速开发的时候，可以方便地从元件面板上拖放元件(component)至表单，完成表单的界面和事件设计。Delphi将这些界面的设计期信息保存在表单相应的 DFM 文件中，方便程序员随时读取和修改。

DFM 文件根据元件在表单上的嵌套层次存放元件属性，以下是一个 DFM 文件的示例：

  object Form1: TForm1
    ...
    Left =192
    Top =107
    Width =544
    Caption ='Form1'
    objectButton1: TButton
     Left = 24
     Top = 16
     Caption = 'Button1'
     onClick = Button1Click
    end
    ...
  end

应用程序编译之后，DFM 文件的信息被二进制化了，这些二进制信息存储在应用程序的资源(resource)段中。每个表单(也就是class)及表单上的元件在资源段中存储为与表单同名的资源，可以使用 FindResource API获得。应用程序在运行期创建表单实例的时候，会从资源段中读取表单的属性，还原设计期的设置。这种将类型信息保存在文件中，并且可以在运行期恢复类型的操作，在本文中被称之为持续(persistent)机制。持续机制是Delphi 成为 RAD 工具的原因之一。

持续机制和 RTTI 是紧密结合的，但本文不讨论 RTTI(关于 RTTI可参考我前几天写的两篇笔记)，只讨论实现持续机制的总体框架及相关类(class)。这些类包括TStream、TFiler、TReader、TWriter、TParser、TPersisetent、TComponent、TCustomForm等。

===============================================================================
⊙ ReadComponentResFile / WriteComponentResFile 函数
===============================================================================
让我们从一个比较直观的例子开始。

Classes.pas 中定义了两个函数 ReadComponentResFile 和WriteComponentResFile，它们的功能是“把元件的属性信息保存到文件”和“从文件中恢复元件属性信息”。

先做个试验。新建一个项目，在 Form1 上放置两个 Button 和一个 Memo。Button 的 Click 事件代码如下。按F9 运行该项目，先在 Memo1 中输入一些字符，然后按下 Button1，再按下 Button2，你会看一个新建的Form。它的属性几乎和 Form1 一样，甚至连 Memo1 中的字符都保存下来了，唯一的不同只是它的 Name属性变成了“Form1_1”。你可以查看 FORM1.RES 文件的内容看看 Delphi 是如何存储元件信息的。

  procedure TForm1.Button1Click(Sender:TObject);
  begin
   WriteComponentResFile('C:\FORM1.RES', Form1);
  end;
 
  procedure TForm1.Button2Click(Sender:TObject);
  var
    NewForm:TForm1;
  begin
    NewForm :=TForm1.CreateNew(Application);
   ReadComponentResFile('C:\FORM1.RES', NewForm);
    NewForm.Left:= NewForm.Left + 100;
  end;

WriteComponentResFile 函数的代码如下，它只是调用 Stream 对象的 WriteComponentRes方法将对象属性保存到资源文件中的：

  procedure WriteComponentResFile(const FileName:string; Instance: TComponent);
  begin
    Stream :=TFileStream.Create(FileName, fmCreate);
   Stream.WriteComponentRes(Instance.ClassName, Instance);
   Stream.Free;
  end;

ReadComponentResFile 函数也是调用 Stream 的方法实现从文件中读取对属信息：

  function ReadComponentResFile(const FileName:string; Instance: TComponent):
   TComponent;
  begin
    Stream :=TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
    Result :=Stream.ReadComponentRes(Instance);
   Stream.Free;
  end;

ReadComponentResFile 函数可以通过 Instance参数传入对象句柄，也可以通过返回值获得对象句柄。Instance 参数只能是已实例化的对象或 nil。如果是 nil，那么ReadComponentResFile 会自动根据文件信息创建对象实例，但必须使用 RegisterClass函数注册将要被载入的类，否则会触发异常。

有个类似的函数 ReadComponentRes，它从应用程序的资源段中恢复对象的属性信息。它的 ResName参数就是表单类的名称：

  function ReadComponentRes(const ResName: string;Instance: TComponent):
   TComponent;

===============================================================================
⊙ Delphi 持续机制框架简述
===============================================================================
持续机制的实现必须由 IDE、编译器、表单类、元件类和辅助类合作完成。

这里的表单类不是指一般所指的 TForm class，在 Delphi 的帮助文件中，称之为“root class”。rootclass 是指能在设计期被 Form Designer 作为最上层编辑表单的类(如TCustomForm、TFrame、TDataModule 等)。Delphi 在设计期将元件的 published 属性的值保存在.DFM 文件中，也只有 published 的属性才能被 Object Insepector 设置赋值。

Form Designer 设计的 root class 对象在编译时，Delphi将对象的属性以及其所包含的元件的属性保存在应用程序的资源段(RT_RCDATA)中。

辅助类包括 TStream、TReader、TWriter、TParser等。这些类起着中间层的作用，用于存储和读取对象属性的信息。虽然我称它们为辅助类，但是保存和恢复对象信息的实际操作是由它们完成的。

===============================================================================
⊙ 一个 TForm 对象的创建过程
===============================================================================
下面是一个典型的表单 Form1 的创建过程，缩进代表调用关系(Form1.ReadState例外，防止缩进太多)，带“?”的函数表示我尚未仔细考察的部分，带“*”表示元件编写者需要注意的函数。

Application.CreateForm(TForm1, Form1);
  |-Form1.NewInstance;
  |-Form1.Create(Application);
   |-Form1.CreateNew(Application);
   |-InitInheritedComponent(Form1, TForm);
     |-InternalReadComponentRes(Form1.ClassName, Form1ResHInst,Form1);
       |-TResourceStream.Create(Form1ResHInst, Form1.ClassName,RT_RCDATA);
       |-TResourceStream.ReadComponent(Form1);
         |-TReader.Create(ResourceStream, 4096);
         |-TReader.ReadRootComponent(Form1);
           |-TReader.ReadSignature;
          *|-TReader.ReadPrefix(Flags, ChildPos);
           |-IF Form1 = nil THEN Form1 := FindClass(ReadStr).Create;
           |-Include(Form1.FComponentState, csLoading);
           |-Include(Form1.FComponentState, csReading);
           |-Form1.Name := FindUniqueName(ReadStr);
          ?|-FFinder := TClassFinder.Create;
          *|-Form1.ReadState(Reader);
             |-TCustomForm.ReadState(Reader);
               { DisableAlign; }
             |-TWinControl.ReadState(Reader);
               { DisableAlign; }
            *|-TControl.ReadState(Reader);
               { Include(FControlState, csReadingState); }
               { Parent :=TWinControl(Reader.Parent);  }
            *|-TComponent.ReadState(Reader);
               |-Reader.ReadData(Form1);
                 |-Reader.ReadDataInner(Form1);
                   |-WHILE NOT EndOfList DO Reader.ReadProperty(Form1);
                     |-IF PropInfo <> nil THENReadPropValue(Form1, PropInfo);
                    *|-ELSE Form1.DefineProperties(Reader);
                   |-WHILE NOT EndOfList DO ReadComponent(nil);
                     |-ReadPrefix(Flags, Position);
                     |-IF ffInherited THEN FindExistingComponent
                     |-ELSE CreateComponent;
                    *|-SubComponent.ReadState(Reader); (Like Form1.ReadState)
                ?|-DoFixupReferences;

过程简述：

TCustomForm.Create 函数中先调用 CreateNew设置缺省的表单属性，然后调用Classes.InitInheritedComponent 函数。

InitInheritedComponent 用于初始化一个 root class对象。该函数的功能就是从应用程序的资源中恢复设计期的表单信息。InitInheritedComponent 的声明如下：

  { Classes.pas }
  function InitInheritedComponent(Instance:TComponent;
   RootAncestor: TClass): Boolean;

InitInheritedComponent 传入两个参数：Instance参数代表将要从资源段中恢复信息的对象，RootAncestor 表示该对象的祖先类。如果从资源中恢复信息成功，则返回True，否则返回 False。InitInheritedComponent 通常只在 root class的构造函数中调用。

  constructor TCustomForm.Create(AOwner:TComponent);
  begin
    ...
   CreateNew(AOwner);                             // 初始化缺省的 Form 属性
   Include(FFormState,fsCreating);               // 标记为 Creating 状态
    if notInitInheritedComponent(Self, TForm) then // 从资源中恢复 Form 信息
     raise EResNotFound.CreateFmt(SResNotFound, [ClassName]);
    ...
   Exclude(FFormState,fsCreating);               // 取消 Creating 状态
  end;

InitInheritedComponent调用自身内置的函数：InitComponent(Instance.ClassType)。InitComponent 先判断Instance.ClassType 是否是 TComponent 或 RootAncestor，如果是则返回 False并退出，否则调用 InternalReadComponentRes。

* InitComponent 递归调用自己检查类信息。没看懂为什么要这样设计，如果有谁看懂了请告诉我。

  function InitComponent(ClassType: TClass):Boolean;
  begin
    Result :=False;
    if(ClassType = TComponent) or (ClassType = RootAncestor) thenExit;
    Result :=InitComponent(ClassType.ClassParent);
    Result :=InternalReadComponentRes(ClassType.ClassName,
     FindResourceHInstance(FindClassHInstance(ClassType)), Instance) orResult;
  end;

InternalReadComponentRes 使用 Instance.ClassName 作为 ResourceName，调用FindResourceHInstance 找到 class 资源所在模块的 HInst 句柄(因为 class可能是在动态链接库中)，并通过引用方式传递 Instance 对象(*好像没有必要使用引用方式，InitInheritedComponent 也没有使用引用方式)：

  { Classes.pas }
  function InternalReadComponentRes(const ResName:string; HInst: THandle;
    varInstance: TComponent): Boolean;

InternalReadComponentRes 先检查 class 资源是否存在，如果存在则创建一个 TResourceStream对象(TResourceStream 的 Create 构造函数把 class 信息的资源内存地址和大小记录在成员字段中)，然后使用TResourceStream.ReadComponent 方法从资源中读取 Instance 的信息。TResourceStream并没有定义 ReadComponent 方法，而是使用祖先类 TStream 的方法。TStream.ReadComponent创建一个 TReader 对象，然后使用自己的对象地址(Self)作为参数，调用 TReader.ReadRootComponent读取 Instance 对象的内容。

  { TReader }
  function ReadRootComponent(Root: TComponent):TComponent;

ReadRootComponent 先调用 TReader.ReadSignature。ReadSignature 从 stream中读取 4 字节的内容，如果读出来的内容不是 'TPF0'，则触发异常(SInvalidImage)，表示该 stream的内容是错误的。然后 ReadRootComponent 调用 ReadPrefix 读取元件的状态信息。

如果 Root 参数是 nil，也就是说 Root 对象还没被创建，则直接从流中读取 Root 的类名，再使用 FindClass函数找到该类在内存中的地址，并调用该类的构造函数创建 Root 的实例。

接下来 ReadRootComponent 调用 Root 的 ReadState 虚函数从流中读取 Root对象的属性。TComponent.ReadState 只有一行代码：Reader.ReadData(Self);。

ReadData 调用 ReadDataInner 读取 root 元件及 root 的子元件的属性信息。

ReadDataInner 先循环调用 ReadProperty 从流中读取 root 元件的属性，直到遇到 EndOfList标志(vaNull)。ReadProperty 使用 RTTI 函数，将从流中读出的数据设置为对象的属性。ReadProperty中还调用了 Instance.DefineProperties，用于实现自定义的属性存储。ReadDataInner 然后循环调用ReadComponent(nil) 读取子元件的信息。

ReadComponent 的执行过程与 ReadRootComponent 的过程很相似，它根据流中的信息使用FindComponentClass 找到元件类在内存中的地址，然后调用该元件类的构造函数创建对象，接下来调用新建对象的ReadState -> TReader.ReadData ->ReadDataInner -> TReader.ReadProperty，重复ReadRootComponent 的过程。

TReader.ReadComponent 和 TComponent.ReadState形成递归调用过程，把表单上嵌套的元件创建出来。

最后 InitInheritedComponent 函数返回，一个 root class 对象从资源中实例化的过程完成。

===============================================================================
⊙ TStream Class 和 TStream.ReadComponent 方法
===============================================================================
TStream 在对象持续机制扮演的角色是提供一种存储媒介，由 TFiler 对象使用。TStream是一个虚类，它定义了数据的“流式”读写方法。它的继承类TFileStream、TMemoryStream、TResourceStream 等实现对不同媒体的读写。对象的persistent 信息可以存储在任何 TStream 类中，也可以从任何 TStream 中获得。由于 Delphi缺省的对象信息存储在应用程序的资源段中，因此，可以从程序的资源段中读取数据的 TResourceStream类就显得更加重要。

TStream 定义两个读写缓冲的方法：ReadBuffer 和 WriteBuffer。这两个方法封装了 TStream.Read和 TStream.Write 纯虚方法(必须被后继类重载)。

  { TStream }
  procedure ReadBuffer(var Buffer; Count:Longint);
  procedure WriteBuffer(const Buffer; Count:Longint);

可以看到这两个方法的 Buffer参数都是无类型的，也就是使用引用的方式传入的，所以不管是使用单个字符或自定义的结构都是正确的(当然，不能使用常量)。Count指示要读或写入的 Buffer 的大小(Bytes)。

TStream 还定义了两个元件信息的读写方法：ReadComponent 和 WriteComponent。由于WriteComponent 通常是由 Delphi 的 IDE/编译器调用的，很难跟踪它的执行过程，所以我们以后主要考察ReadComponent 方法。我们可以很容易想像这两个方法互为逆过程，理解了其中一个也就能知道另一个所做的工作。

  { TStream }
  function ReadComponent(Instance: TComponent):TComponent;
  procedure WriteComponent(Instance:TComponent);

TStream.ReadComponent 创建了一个 TReader 对象，将自己的对象地址作为参数传递给 Reader，并调用Reader.ReadRootComponent 创建对象实例。

  function TStream.ReadComponent(Instance:TComponent): TComponent;
  var
    Reader:TReader;
  begin
    Reader :=TReader.Create(Self,4096);       // 4096 是缓冲区大小
    Result :=Reader.ReadRootComponent(Instance);
   Reader.Free;
  end;

TStream 把自己的对象句柄交给 TReader 之后，就成了 TReader 读取对象属性资料的来源。此后 TStream对象只由 TReader 来掌控，自己不再主动进行其它工作。

===============================================================================
⊙ TReader Class 和 TReader.ReadRootComponent 方法
===============================================================================
TReader 和 TWriter 都是从 TFiler 继承下来的类。TFiler 是个纯虚类，它的构造函数被 TReader 和TWrite 共享。TFiler.Create 先把 Stream 参数保存在 FStream字段中，然后生成一个自己的缓冲区：

  constructor TFiler.Create(Stream: TStream;BufSize: Integer);
  begin
    FStream :=Stream;         // 保存 stream 对象
   GetMem(FBuffer, BufSize);   //创建自己的缓冲区，加速数据访问
    FBufSize :=BufSize;       // 设置缓冲区大小
  end;

上面说到 TStream.ReadComponent 在创建 TReader 对象之后，立即调用TReader.ReadRootComponent 方法。TReader.ReadRootComponent 方法的功能是从stream 中读取 root class 对象的属性。并返回该对象的指针。

  { TReader }
  function ReadRootComponent(Root: TComponent):TComponent;

ReadRootComponent 先调用 TReader.ReadSignature。

TReader.ReadSignature 方法从 stream 中读取 4 字节的内容，如果读出来的内容不是'TPF0'，则触发异常(SInvalidImage)，表示该 stream 的内容是错误的。'TPF0' 就是 root class对象的标记。

然后 ReadRootComponent 调用 ReadPrefix 读取元件的继承信息。

如果 Root 参数是 nil，也就是说 Root 对象还没被创建，则直接从流中读取 Root 的类名，再使用 FindClass函数找到该类在内存中的地址，并调用该类的构造函数创建 Root 的实例。如果 Root 实例已存在，则调用内嵌的FindUniquName 函数检查 Root.Name 是否与已有的实例重复，如有重复则在 Root.Name后加上序号使其唯一。

接下来 ReadRootComponent 调用 Root 的 ReadState 虚方法从流中读取 Root对象的属性。

===============================================================================
⊙ TReader.ReadPrefix 方法
===============================================================================
ReadPrefix 方法用于读取元件的状态信息，这些信息是由 Writer 在写入元件属性之前写入的。

  { TReader }
  procedure ReadPrefix(var Flags: TFilerFlags; varAChildPos: Integer); virtual;

Flags 参数是以引用方式传递的，用于设置元件的在表单中的状态，元件的状态在这里包含三种情况：

  ffInherited：表示元件存在于表单的父类之中
  ffChildPos ：表示元件在表单中的创建次序(creationorder)是重要的
  ffInline  ：表示元件是最上级(top-level)的元件，比如表单或数据模块

如果元件的状态中包含 ffChildPos，ReadPrefix 还会读取元件的创建次序值，存放在 AChildPos参数中。

===============================================================================
⊙ TComponent.ReadState 虚方法
===============================================================================
设置 ReadState 方法的主要目的是在读取属性信息的前后可以让元件进行一些处理工作。ReadState 是 ComponentWriter 需要注意的方法。

  { TComponent }
  procedure ReadState(Reader: TReader);virtual;

由于 ReadState 是虚函数，在 TControl、TWinControl、TCustomForm等后续类中都被重载，进行自己需要的操作(比如 DisableAlign、UpdateControlState)。

TComponent.ReadState 只有一行代码：Reader.ReadData(Self);

注意：自己重载 ReadState 方法必须调用 inherited 。

===============================================================================
⊙ TReader.ReadData 方法
===============================================================================
上面说到 TComponent.ReadState 又回头调用 TReader.ReadData 方法。它的主要代码如下：

  { TReader }
  procedure TReader.ReadData(Instance:TComponent);
  begin
    ...
   ReadDataInner(Instance);
   DoFixupReferences;
    ...
  end;

TReader.ReadData 基本上是个包装函数，它调用 TReader.ReadDataInner 读取 root 对象及root 所包含的元件的属性信息。

===============================================================================
⊙ TReader.ReadDataInner 方法
===============================================================================
ReadDataInner 负责读取元件的属性和子元件的属性，它的主要代码如下：

  procedure TReader.ReadDataInner(Instance:TComponent);
    begin
    ...
    while notEndOfList do ReadProperty(Instance);
    ...
    while notEndOfList do ReadComponent(nil);
    ...
  end;

ReadDataInner 先循环调用 ReadProperty 从流中读取对象的属性，直到遇到 EndOfList标志(vaNull)。再循环调用 ReadComponent(nil) 读取子元件的信息。这两个方法都是 TReader的重要方法，后面分两节讨论。ReadDataInner 在ReadProperty 调用之后还设置了元件的 Parent 和Owner 关系。

===============================================================================
⊙ TReader.ReadProperty 方法
===============================================================================
ReadProperty 使用 RTTI 函数将从流中读出的数据设置为对象的属性。它先解析从流中读出的属性名称，然后判断该属性是否有RTTI 信息，如果有则调用 TReader.ReadPropValue 方法从流中读取属性值；如果该属性没有 RTTI信息，说明该属性不属于 published 段，而是由元件自己写入的，因此调用TPersistent.DefineProperties 读取自定义的元件信息。ReadProperty 的关键代码：

  procedure TReader.ReadProperty(AInstance:TPersistent);
  begin
    ...
    PropInfo :=GetPropInfo(Instance.ClassInfo, FPropName);
    if PropInfo<> nilthen                            // 检查属性 RTTI 信息
     ReadPropValue(Instance,PropInfo)                // 从流中读取属性
    elsebegin
     Instance.DefineProperties(Self);                 // 调用自定义存储过程
     if FPropName <> '' thenPropertyError(FPropName); // 注意这里
    end;
    ...
  end;

ReadPropValue 方法基本上是使用SetOrdProp、SetFloatProp、SetStrProp、GetEnumValue 等 RTTI函数设置元件的属性值，它的代码冗长而简单，不再单独列出。下面介绍比较重要的 DefineProperties 函数。

===============================================================================
⊙ TPersistent.DefineProperties 虚方法
===============================================================================
DefineProperties 虚方法用于元件设计者自定义非 published 属性的存储和读取方法。 TPersistent定义的该方法是个空方法，到 TComponent 之后被重载。

   procedureTPersistent.DefineProperties(Filer: TFiler); virtual;

下面以 TComponent 为例说明该方法的用法：

  procedure TComponent.DefineProperties(Filer:TFiler);
  var
    Ancestor:TComponent;
    Info:Longint;
  begin
    Info :=0;
    Ancestor :=TComponent(Filer.Ancestor);
    if Ancestor<> nil then Info :=Ancestor.FDesignInfo;
   Filer.DefineProperty('Left', ReadLeft, WriteLeft,
     LongRec(FDesignInfo).Lo <>LongRec(Info).Lo);
   Filer.DefineProperty('Top', ReadTop, WriteTop,
     LongRec(FDesignInfo).Hi <>LongRec(Info).Hi);
  end;

DefineProperties 调用 Filer.DefineProperty 或 DefineBinaryProperty方法读写流中属性值。

TReader.DefineProperty 方法检查传入的属性名称是否与当前流中读到的属性名称相同，如果相同，则调用传入的ReadData 方法读取数据，并设置 FPropName 为空，用以通知 ReadProperty已经完成读属性值的工作，否则将会触发异常。

  procedure TReader.DefineProperty(const Name:string;
    ReadData:TReaderProc; WriteData: TWriterProc; HasData: Boolean);
  begin
    ifSameText(Name, FPropName) and Assigned(ReadData) then
    begin
     ReadData(Self);
     FPropName := '';
    end;
  end;

TWriter.DefineProperty 根据 HasData 参数决定是否需要写属性值。

  procedure TWriter.DefineProperty(const Name:string;
    ReadData:TReaderProc; WriteData: TWriterProc; HasData: Boolean);
  begin
    if HasDataand Assigned(WriteData) then
    begin
     WritePropName(Name);
     WriteData(Self);
    end;
  end;

如果 Filer.Ancestor 不是 nil，表示当前正在读取的元件继承自表单父类中的元件，元件设计者可以根据 Ancestor判断是否需要写属性至流中。例如：当前元件的属性值与原表单类中的元件属性值相同的时候，可以不写入(通常是这样设计)。

ReadData、WriteData 参数是从 Filer 对象中读写数据的方法地址，它们的类型是：

  TReaderProc = procedure(Reader: TReader) ofobject;
  TWriterProc = procedure(Writer: TWriter) ofobject;

比如：

  procedure TComponent.ReadLeft(Reader:TReader);
  begin
   LongRec(FDesignInfo).Lo := Reader.ReadInteger;
  end;

  procedure TComponent.WriteLeft(Writer:TWriter);
  begin
   Writer.WriteInteger(LongRec(FDesignInfo).Lo);
  end;
 
对于二进制格式的属性值，可以使用 TFiler.DefineBinaryProperty 方法读写：

  procedure DefineBinaryProperty(const Name:string;
    ReadData,WriteData: TStreamProc; HasData: Boolean); override;

  TStreamProc = procedure(Stream: TStream) ofobject;

Stream 参数是从流中读出的二进制数据或要写入二进制数据的流对象句柄。

注意：自己定义属性的读写方法时要记得调用 inheritedDefineProperties(Filer)，否则祖先类的自定义属性读写操作不会进行。TControl 是个例外，因为它已经定义了published Left 和 Top 属性。

===============================================================================
⊙ TReader.ReadComponent 方法
===============================================================================
ReadComponent 的执行过程与 ReadRootComponent 的过程很相似，它根据流中的信息使用FindComponentClass 方法找到元件类在内存中的地址，然后调用该元件类的构造函数创建对象，接下来调用新建对象的ReadState -> TReader.ReadData ->ReadDataInner -> TReader.ReadProperty，重复ReadRootComponent 的过程。

  { TReader }
  function ReadComponent(Component: TComponent):TComponent;

TReader.ReadComponent 和 TComponent.ReadState形成递归调用过程，把表单上嵌套的元件创建出来。

===============================================================================
⊙ TReader.ReadValue / TReader.NextValue 系列方法
===============================================================================
ReadValue 方法从流中读出一个 TValueType 类型的数据，它主要由其它的方法调用。

TValueType 中只有 vaList 比较特殊，它表示后面的数据是一个属性值系列，以 vaNull结束。其余的枚举值的都是指属性的数据类型或值。

  TValueType = (vaNull, vaList, vaInt8, vaInt16,vaInt32, vaExtended,
    vaString,vaIdent, vaFalse, vaTrue, vaBinary, vaSet, vaLString,
    vaNil,vaCollection, vaSingle, vaCurrency, vaDate, vaWString,
    vaInt64,vaUTF8String);

  function TReader.ReadValue: TValueType;
  begin
    Read(Result,SizeOf(Result));
  end;

NextValue 方法调用 ReadValue返回流中下一个数据的类型，然后将流指针回退至读数据之前。通常用于检测流中下一个数据的类型。

  function TReader.NextValue: TValueType;
  begin
    Result :=ReadValue;
   Dec(FBufPos);
  end;

CheckValue 方法调用 ReadValue 检查下一个数据类型是否是指定的类型，如果不是则触发异常。

ReadListBegin 方法检查下一个数据是否是 vaList，它调用 CheckValue 方法。

ReadListEnd 方法检查下一个数据是否是 vaNull，它调用 CheckValue 方法。

SkipValue 方法使用 ReadValue 获得下一个数据的类型，然后将流指针跳过这个数据。

===============================================================================
⊙ TReader.ReadStr 方法
===============================================================================
ReadStr 方法读出流中的短字符串，TReader 内部使用它读取属性名称等字符串，元件设计者应该使用 ReadString函数读取属性值。

  function ReadStr: string;

===============================================================================
⊙ TReader.ReadInteger / ReadString / ReadBoolean 系列方法
===============================================================================
TReader 有一系列读取属性值的函数，可供元件设计者使用。

    functionReadInteger: Longint;
    functionReadInt64: Int64;
    functionReadBoolean: Boolean;
    functionReadChar: Char;
    procedureReadCollection(Collection: TCollection);
    functionReadFloat: Extended;
    functionReadSingle: Single;
    functionReadCurrency: Currency;
    functionReadDate: TDateTime;
    functionReadIdent: string;
    functionReadString: string;
    functionReadWideString: WideString;
    functionReadVariant: Variant;

===============================================================================
⊙ TReader.Read 方法
===============================================================================
TReader 中所有的数据都是通过 TReader.Read 方法读取的。TReader 不直接调用 TStream 的读方法是因为TReader 的读数据操作很频繁，它自己建立了一个缓冲区(4K)，只有当缓冲区中的数据读完之后才会调用 TStream.Read再读入下一段数据，这样可以极大地加快读取速度。Read 是个汇编函数，编写得很巧妙，它的代码及注释如下：

procedure TReader.Read(var Buf; Count: Longint); assembler;
asm
       PUSH   ESI
       PUSH   EDI
       PUSH   EBX
       MOV    EDI,EDX                   ; EDI <- @Buf
       MOV    EBX,ECX                   ; EBX <- Count
       MOV    ESI,EAX                   ; ESI <- Self
       JMP    @@6                       ; check if Count = 0
     { @@1: 检查 TReader 的缓冲数据是否用尽 }
@@1:   MOV    ECX,[ESI].TReader.FBufEnd  ; ECX <-FBufEnd
       SUB    ECX,[ESI].TReader.FBufPos  ; if FBufEnd> FBufPos jmp @@2
       JA     @@2
       MOV    EAX,ESI                   ; else EAX <- Self
       CALL   TReader.ReadBuffer        ; call ReadBuffer
       MOV    ECX,[ESI].TReader.FBufEnd  ; ECX <-FBufEnd
     { @@2: 检查要读出的数量是否超过缓冲区大小，如是则分批读取 }
@@2:   CMP    ECX,EBX                   ; if FBufEnd < Count jmp @@3
       JB     @@3
       MOV    ECX,EBX                   ; else ECX <- Count
     { @@3: 分批读取缓冲区 }
@@3:   PUSH   ESI
       SUB    EBX,ECX                   ; Count = Count - FBufEnd
       MOV    EAX,[ESI].TReader.FBuffer  ; EAX <-FBuffer
       ADD    EAX,[ESI].TReader.FBufPos  ; EAX = FBuffer +FBufPos
       ADD    [ESI].TReader.FBufPos,ECX  ; FBufPos = FBufPos +FBufEnd
       MOV    ESI,EAX                   ; ESI <- Curr FBuffer Addr
       MOV    EDX,ECX                   ; EDX <- FBufEnd
       SHR    ECX,2                     ; ECX <- FBufEnd / 4
       CLD
       REP    MOVSD                     ; Copy Buffer
       MOV    ECX,EDX                   ; ECX <- FBufEnd
       AND    ECX,3                     ; Check if FBufEnd Loss 3
       REP    MOVSB                     ; Copy left Buff
       POP    ESI                       ; ESI <- Self
     { @@6: 检查是否读完数据，然后重复 @@1 或退出 }
@@6:   OR     EBX,EBX                   ; if Count = 0 then Exit
       JNE    @@1                       ; Repeat ReadBuffer
       POP    EBX
       POP    EDI
       POP    ESI
end;

===============================================================================
⊙ ObjectBinaryToText / ObjectTextToBinary 函数
===============================================================================
Classes.pas 中的 ObjectBinaryToText 和 ObjectTextToBinary函数用于把对象属性信息转换为文本形式或二进制形式。

  procedure ObjectBinaryToText(Input, Output:TStream);
  procedure ObjectTextToBinary(Input, Output:TStream);

新建一个项目，在表单上放置一个 TMemo 控件，然后执行以下代码，就能明白这两个函数的作用了。在 Delphi 的 IDE 中，将DFM 文件进行二进制和文本方式的转换应该是通过这两个函数进行的。

  var
    InStream,OutStream: TMemoryStream;
  begin
    InStream :=TMemoryStream.Create;
    OutStream :=TMemoryStream.Create;
   InStream.WriteComponent(Self);
   InStream.Seek(0, soFromBeginning);
   ObjectBinaryToText(InStream, OutStream);
   OutStream.Seek(0, soFromBeginning);
   Memo1.Lines.LoadFromStream(OutStream);
  end;

上面的两个函数还有一对增强版本，它们增加了对资源文件格式的转换，实际上也是调用了上面的函数：

  procedure ObjectResourceToText(Input, Output:TStream);
  procedure ObjectTextToResource(Input, Output:TStream);

Delphi 编译程序生成应用程序的资源数据段，应该是用 ObjectTextToResource 函数进行的。

注：ObjectTextToBinary 调用了 TParser 对象进行字符串解析工作。




目录
===============================================================================
⊙ RTTI 简介
⊙ 类(class) 和 VMT 的关系
⊙ 类(class)、类的类(class of class)、类变量(class variable) 的关系
⊙ TObject.ClassType 和 TObject.ClassInfo
⊙ is 和 as 运算符的原理
⊙ TTypeInfo – RTTI 信息的结构
⊙ 获取类(class)的属性(property)信息
⊙ 获取方法(method)的类型信息
⊙ 获取有序类型(ordinal)、集合(set)类型的 RTTI 信息
⊙ 获取其它数据类型的 RTTI 信息
===============================================================================

本文排版格式为：
   正文由窗口自动换行；所有代码以 80 字符为边界；中英文字符以空格符分隔。

(作者保留对本文的所有权利，未经作者同意请勿在在任何公共媒体转载。)


正文
===============================================================================
⊙ RTTI 简介
===============================================================================

RTTI(Run-Time Type Information)翻译过来的名称是“运行期类型信息”，也就是说可以在运行期获得数据类型或类(class)的信息。这个 RTTI到底有什么用处，我现在也说不清楚。我是在阅读 Delphi 持续机制的代码中发现了很多 RTTI 的运用，只好先把 RTTI学习一遍。下面是我的学习笔记。如果你发现了错误请告诉我。谢谢！

Delphi 的 RTTI 主要分为类(class)的 RTTI 和一般数据类型的 RTTI，下面从类(class)开始。

===============================================================================
⊙ 类(class) 和 VMT 的关系
===============================================================================

一个类(class)，从编译器的角度来看就是一个指向 VMT 的指针(在后文用 VMTptr 表示)。在类的 VMTptr的负地址方向存储了一些类信息的指针，这些指针的值和指针所指的内容在编译后就确定了。比如 VMTptr - 44的内容是指向类名称(ClassName)的指针。不过一般不使用数值来访问这些类信息，而是通过 System.pas 中定义的以 vmt开头的常量，如 vtmClassName、vmtParent 等来访问。

类的方法有两种：对象级别的方法和类级别的方法。两者的 Self 指针意义是不同的。在对象级别的方法中 Self指向对象地址空间，因此可以用它来访问对象的成员函数；在类级别的方法中 Self 指向类的 VMT，因此只能用它来访问 VMT信息，而不能访问对象的成员字段。

===============================================================================
⊙ 类(class)、类的类(class of class)、类变量(class variable) 的关系
===============================================================================

上面说到类(class) 就是 VMTptr。在 Delphi 中还可以用 class of关键字定义类的类，并且可以使用类的类定义类变量。从语法上理解这三者的关键并不难，把类当成普通的数据类型来考虑就可以了。在编译器级别上表现如何呢？

为了简化讨论，我们使用 TObject、TClass 和 TMyClass 来代表上面说的三种类型：

type
  TClass = class of TObject;
var
  TMyClass: TClass;
  MyObject: TObject;
begin
  TMyClass := TObject;
  MyObject := TObject.Create;
  MyObject := TClass.Create;
  MyObject := TMyClass.Create;
end;
 
在上面的例子中，三个 TObject 对象都被成功地创建了。编译器的实现是：TObject 是一个 VMTPtr 常量。TClass也是一个 VMTptr 常量，它的值就是 TObject。TMyClass 是一个 VMTptr 变量，它被赋值为TObject。TObject.Create 与 TClass.Create 的汇编代码完全相同。但 TClass不仅缺省代表一个类，而且还(主要)代表了类的类型，可以用它来定义类变量，实现一些类级别的操作。

===============================================================================
⊙ TObject.ClassType 和 TObject.ClassInfo
===============================================================================

function TObject.ClassType: TClass;
begin
  Pointer(Result) := PPointer(Self)^;
end;

TObject.ClassType 是对象级别的方法，Self 的值是指向对象内存空间的指针，对象内存空间的前 4 个字节是类的VMTptr。因此这个函数的返回值就是类的 VMTptr。

class function TObject.ClassInfo: Pointer;
begin
  Result := PPointer(Integer(Self) +vmtTypeInfo)^;
end;

TObject.ClassInfo 使用 class 关键字定义，因此是一个类级别的方法。该方法中的 Self 指针就是VMTptr。所以这个函数的返回值是 VMTptr 负方向的 vmtTypeInfo 的内容。

TObject.ClassInfo 返回的 Pointer 指针，实际上是指向类的 RTTI 结构的指针。但是不能访问TObject.ClassInfo 指向的内容(TObject.ClassInfo 返回值是 0)，因为 Delphi 只在TPersistent 类及 TPersistent 的后继类中产生 RTTI 信息。(从编译器的角度来看，这是在TPersistent 类的声明之前使用 {$M+} 指示字的结果。)

TObject 还定义了一些获取类 RTTI 信息的函数，列举在下，就不一一分析了：

  TObject.ClassName:ShortString;   类的名称
  TObject.ClassParent:TClass;     对象的父类
  TObject.InheritsFrom:Boolean;   是否继承自某类
  TObject.InstanceSize:Longint;   对象实例的大小

===============================================================================
⊙ is 和 as 运算符的原理
===============================================================================

我们知道可以在运行期使用 is 关键字判断一个对象是否属于某个类，可以使用 as关键字把某个对象安全地转换为某个类。在编译器的层次上，is 和 as 的操作是由 System.pas 中两个函数完成的。

{ System.pas }
function _IsClass(Child: TObject; Parent: TClass): Boolean;
begin
  Result := (Child<> nil) andChild.InheritsFrom(Parent);
end;

_IsClass 很简单，它使用 TObject 的 InheritsForm函数判断该对象是否是从某个类或它的父类中继承下来的。每个类的 VMT 中都有一项 vmtParent 指针，指向该类的父类的VMT。TObject.InheritsFrom 实际上是通过[递归]判断父类 VMT 指针是否等于自己的 VMT指针来判断是否是从该类继承的。

{ System.pas }
class function TObject.InheritsFrom(AClass: TClass): Boolean;
var
  ClassPtr: TClass;
begin
  ClassPtr := Self;
  while (ClassPtr <>nil) and (ClassPtr <> AClass)do
    ClassPtr :=PPointer(Integer(ClassPtr) + vmtParent)^;
  Result := ClassPtr = AClass;
end;

as 操作符实际上是由 System.pas 中的 _AsClass 函数完成的。它简单地调用 is操作符判断对象是否属于某个类，如果不是就触发异常。虽然 _AsClass 返回值为 TObject类型，但编译器会自动把返回的对象改变为 Parent 类，否则返回的对象没有办法使用 TObject 之外的方法和数据。

{ System.pas }
function _AsClass(Child: TObject; Parent: TClass): TObject;
begin
  Result := Child;
  if not (Child is Parent) then
   Error(reInvalidCast);   // losesreturn address
end;

===============================================================================
⊙ TTypeInfo – RTTI 信息的结构
===============================================================================

RTTI 信息的结构定义在 TypInfo.pas 中：

  TTypeInfo =record       // TTypeInfo 是 RTTI 信息的结构
    Kind:TTypeKind;       // RTTI 信息的数据类型
    Name:ShortString;     // 数据类型的名称
   {TypeData:TTypeData}    //RTTI 的内容
  end;

TTypeInfo 就是 RTTI 信息的结构。TObject.ClassInfo 返回指向存放 class TTypeInfo信息的指针。Kind 是枚举类型，它表示 RTTI 结构中所包含数据类型。Name 是数据类型的名称。注意，最后一个字段TypeData 被注释掉了，这说明该处的结构内容根据不同的数据类型有所不同。

TTypeKind 枚举定义了可以使用 RTTI 信息的数据类型，它几乎包含了所有的 Delphi 数据类型，其中包括tkClass。

  TTypeKind = (tkUnknown, tkInteger, tkChar,tkEnumeration, tkFloat,
    tkString,tkSet, tkClass, tkMethod, tkWChar, tkLString, tkWString,
    tkVariant,tkArray, tkRecord, tkInterface, tkInt64, tkDynArray);

TTypeData 是个巨大的记录类型，在此不再列出，后文会根据需要列出该记录的内容。

===============================================================================
⊙ 获取类(class)的属性(property)信息
===============================================================================

这一段是 RTTI 中最复杂的部分，努力把本段吃透，后面的内容都是非常简单的。

下面是一个获取类的属性的例子：

procedure GetClassProperties(AClass: TClass; AStrings:TStrings);
var
  PropCount, I: SmallInt;
  PropList: PPropList;
  PropStr: string;
begin
  PropCount :=GetTypeData(AClass.ClassInfo).PropCount;
  GetPropList(AClass.ClassInfo, PropList);
  for I := 0 to PropCount - 1 do
  begin
    casePropList[I]^.PropType^.Kind of
     tkClass     : PropStr := '[Class] ';
     tkMethod    : PropStr := '[Method]';
     tkSet       : PropStr := '[Set]   ';
     tkEnumeration: PropStr := '[Enum]  ';
    else
     PropStr := '[Field] ';
    end;
    PropStr :=PropStr + PropList[I]^.Name;
    PropStr :=PropStr + ': ' + PropList[I]^.PropType^.Name;
   AStrings.Add(PropStr);
  end;
  FreeMem(PropList);
end;

你可以在表单上放置一个 TListBox ，然后执行以下语句观察执行结果：

  GetClassProperties(TForm1,ListBox1.Items);

该函数先使用 GetTypeData 函数获得类的属性数量。GetTypeData 是 TypInfo.pas中的一个函数，它的功能是返回 TTypeInfo 的 TypeData 数据的指针：

{ TypInfo.pas }
function GetTypeData(TypeInfo: PTypeInfo): PTypeData;assembler;

class 的 TTypeData 结构如下：

  TTypeData = packed record
    caseTTypeKind of
     tkClass: (
       ClassType:TClass;        // 类 (VMTptr)
       ParentInfo:PPTypeInfo;   // 父类的 RTTI 指针
       PropCount:SmallInt;      // 属性数量
       UnitName: ShortStringBase; // 单元的名称
      {PropData:TPropData});    // 属性的详细信息
  end;

其中的 PropData 又是一个大小可变的字段。TPropData 的定义如下：

  TPropData = packed record
    PropCount:Word;      // 属性数量
    PropList:record end;  // 占位符，真正的意义在下一行
    {PropList:array[1..PropCount] of TPropInfo}
  end;

每个属性信息在内存中的结构就是 TPropInfo，它的定义如下：

  PPropInfo = ^TPropInfo;
  TPropInfo = packed record
    PropType:PPTypeInfo;   // 属性类型信息指针的指针
    GetProc:Pointer;       // 属性的 Get 方法指针
    SetProc:Pointer;       // 属性的 Set 方法指针
    StoredProc:Pointer;    // 属性的 StoredProc 指针
    Index:Integer;         // 属性的 Index 值
    Default:Longint;       // 属性的 Default 值
    NameIndex:SmallInt;    // 属性的名称索引(以 0 开始计数)
    Name:ShortString;      // 属性的名称
  end;

为了方便访问属性信息，TypInfo.pas 中还定义了指向 TPropInfo 数组的指针：

  PPropList = ^TPropList;
  TPropList = array[0..16379] of PPropInfo;

我们可以使用 GetPropList 获得所有属性信息的指针数组，数组用完以后要记得用 FreeMem 把数组的内存清除。

{ TypInfo.pas }
function GetPropList(TypeInfo: PTypeInfo; out PropList: PPropList):Integer;

GetPropList 传入类的 TTypeInfo 指针和 TPropList 的指针，它为 PropList分配一块内存后把该内存填充为指向 TPropInfo 的指针数组，最后返回属性的数量。

上面的例子演示了如何获得类的所有属性信息，也可以根据属性的名称单独获得属性信息：

{ TypInfo.pas }
function GetPropInfo(TypeInfo: PTypeInfo; const PropName: string):PPropInfo;

GetPropInfo 根据类的 RTTI 指针和属性的名称字符串，返回属性的信息 TPropInfo的指针。如果没有找到该属性，则返回 nil。GetPropInfo 很容易使用，举个例子：

  ShowMessage(GetPropInfo(TForm,'Name')^.PropType^.Name);

这句调用显示了 TForm 类的 Name 属性的类型名称：TComponentName。

===============================================================================
⊙ 获取方法(method)的类型信息
===============================================================================

所谓方法就是以 of object 关键字声明的函数指针，下面的函数可以显示一个方法的类型信息：

procedure GetMethodTypeInfo(ATypeInfo: PTypeInfo; AStrings:TStrings);
type
  PParamData = ^TParamData;
  TParamData =record      // 函数参数的数据结构
    Flags:TParamFlags;    // 参数传递规则
    ParamName:ShortString; // 参数的名称
    TypeName:ShortString;  // 参数的类型名称
  end;
  function GetParamFlagsName(AParamFlags:TParamFlags): string;
  var
    I:Integer;
  begin
    Result :='';
    for I :=Integer(pfVar) to Integer(pfOut) do begin
     if I = Integer(pfAddress) then Continue;
     if TParamFlag(I) in AParamFlags then
       Result := Result + ' ' + GetEnumName(TypeInfo(TParamFlag),I);
    end;
  end;
var
  MethodTypeData: PTypeData;
  ParamData: PParamData;
  TypeStr: PShortString;
  I: Integer;
begin
  MethodTypeData := GetTypeData(ATypeInfo);
 AStrings.Add('---------------------------------');
  AStrings.Add('Method Name: ' +ATypeInfo^.Name);
  AStrings.Add('Method Kind: ' +GetEnumName(TypeInfo(TMethodKind),
   Integer(MethodTypeData^.MethodKind)));
  AStrings.Add('Params Count: '+IntToStr(MethodTypeData^.ParamCount));
  AStrings.Add('Params List:');
  ParamData :=PParamData(@MethodTypeData^.ParamList);
  for I := 1 to MethodTypeData^.ParamCountdo
  begin
    TypeStr :=Pointer(Integer(@ParamData^.ParamName) +
     Length(ParamData^.ParamName) + 1);
   AStrings.Add(Format('  [%s] %s:%s',[GetParamFlagsName(ParamData^.Flags),
     ParamData^.ParamName, TypeStr^]));
    ParamData :=PParamData(Integer(ParamData) + SizeOf(TParamFlags) +
     Length(ParamData^.ParamName) + Length(TypeStr^) + 2);
  end;
  if MethodTypeData^.MethodKind = mkFunctionthen
   AStrings.Add('Result Value: ' + PShortString(ParamData)^);
end;

作为实验，在表单上放置一个 TListBox，然后执行以下代码，观察执行结果：

type
  TMyMethod = function(A: array of Char; var B:TObject): Integer of object;
procedure TForm1.FormCreate(Sender: TObject);
begin
  GetMethodTypeInfo(TypeInfo(TMyMethod),ListBox1.Items);
  GetMethodTypeInfo(TypeInfo(TMouseEvent),ListBox1.Items);
  GetMethodTypeInfo(TypeInfo(TKeyPressEvent),ListBox1.Items);
  GetMethodTypeInfo(TypeInfo(TMouseWheelEvent),ListBox1.Items);
end;

由于获取方法的类型信息比较复杂，我尽量压缩代码也还是有这么长，让我们看看它的实现原理。GetMethodTypeInfo的第一个参数是 PTypeInfo 类型，表示方法的类型信息地址。第二个参数是一个字符串列表，可以使用任何实现 TStrings操作的对象。我们可以使用 System.pas 中的 TypeInfo 函数获得任何类型的 RTTI 信息指针。TypeInfo函数像 SizeOf 一样，是内置于编译器中的。

GetMethodTypeInfo 还用到了 TypInfo.pas 中的 GetEnumName函数。这个函数通过枚举类型的整数值得到枚举类型的名称。

function GetEnumName(TypeInfo: PTypeInfo; Value: Integer):string;

与获取类(class)的属性信息类似，方法的类型信息也在 TTypeData 结构中

  TTypeData = packed record
    caseTTypeKind of
     tkMethod: (
       MethodKind:TMethodKind;           // 方法指针的类型
       ParamCount:Byte;                  // 参数数量
       ParamList: array[0..1023] ofChar   // 参数详细信息，见下行注释
      {ParamList: array[1..ParamCount] of
         record
           Flags:TParamFlags;            // 参数传递规则
           ParamName:ShortString;        // 参数的名称
           TypeName:ShortString;         // 参数的类型
         end;
       ResultType:ShortString});         // 返回值的名称
  end;

TMethodKind 是方法的类型，定义如下：

  TMethodKind = (mkProcedure, mkFunction,mkConstructor, mkDestructor,
   mkClassProcedure, mkClassFunction,
    { Obsolete}
   mkSafeProcedure, mkSafeFunction);

TParamsFlags 是参数传递的规则，定义如下：

  TParamFlag = (pfVar, pfConst, pfArray,pfAddress, pfReference, pfOut);
  TParamFlags = set of TParamFlag;

由于 ParamName 和 TypeName是变长字符串，不能直接取用该字段的值，而应该使用指针步进的方法，取出参数信息，所以上面的代码显得比较长。

===============================================================================
⊙ 获取有序类型(ordinal)、集合(set)类型的 RTTI 信息
===============================================================================

讨论完了属性和方法的 RTTI 信息之后再来看其它数据类型的 RTTI 就简单多了。所有获取 RTTI 的原理都是通过GetTypeData 函数得到 TTypeData 的指针，再通过 TTypeInfo.TypeKind 来解析TTypeData。任何数据类型的 TTypeInfo 指针可以通过 TypeInfo 函数获得。

有序类型的 TTypeData 定义如下：

TTypeData = packed record
  tkInteger, tkChar, tkEnumeration, tkSet,tkWChar: (
    OrdType:TOrdType;        // 有序数值类型
    caseTTypeKind of
     case TTypeKind of
       tkInteger, tkChar, tkEnumeration, tkWChar: (
         MinValue: Longint;   //类型的最小值
         MaxValue: Longint;   //类型的最大值
         case TTypeKind of
           tkInteger, tkChar, tkWChar: ();
           tkEnumeration: (
             BaseType:PPTypeInfo;     // 指针的指针，它指向枚举的 PTypeInfo
             NameList:ShortStringBase;    // 枚举的名称字符串(不能直接取用)
             EnumUnitName: ShortStringBase)); // 所在的单元名称(不能直接取用)
         tkSet: (
           CompType:PPTypeInfo));           // 指向集合基类 RTTI 指针的指针
end;

下面是一个获取有序类型和集合类型的 RTTI 信息的函数：

procedure GetOrdTypeInfo(ATypeInfo: PTypeInfo; AStrings:TStrings);
var
  OrdTypeData: PTypeData;
  I: Integer;
begin
  OrdTypeData := GetTypeData(ATypeInfo);
 AStrings.Add('------------------------------------');
  AStrings.Add('Type Name: ' +ATypeInfo^.Name);
  AStrings.Add('Type Kind: ' +GetEnumName(TypeInfo(TTypeKind),
   Integer(ATypeInfo^.Kind)));
  AStrings.Add('Data Type: ' +GetEnumName(TypeInfo(TOrdType),
   Integer(OrdTypeData^.OrdType)));
  if ATypeInfo^.Kind<> tkSet then begin
   AStrings.Add('Min Value: ' +IntToStr(OrdTypeData^.MinValue));
   AStrings.Add('Max Value: ' +IntToStr(OrdTypeData^.MaxValue));
  end;
  if ATypeInfo^.Kind = tkSet then
   GetOrdTypeInfo(OrdTypeData^.CompType^, AStrings);
  if ATypeInfo^.Kind = tkEnumeration then
    for I :=OrdTypeData^.MinValue to OrdTypeData^.MaxValue do
     AStrings.Add(Format('  Value %d: %s', [I,GetEnumName(ATypeInfo, I)]));
end;

在表单上放置一个 TListBox，运行以下代码查看结果：

type TMyEnum = (EnumA, EnumB, EnumC);
procedure TForm1.FormCreate(Sender: TObject);
begin
  GetOrdTypeInfo(TypeInfo(Char),ListBox1.Items);
  GetOrdTypeInfo(TypeInfo(Integer),ListBox1.Items);
  GetOrdTypeInfo(TypeInfo(TFormBorderStyle),ListBox1.Items);
  GetOrdTypeInfo(TypeInfo(TBorderIcons),ListBox1.Items);
  GetOrdTypeInfo(TypeInfo(TMyEnum),ListBox1.Items);
end;

(如果枚举元素没有按缺省的 0 基准定义，那么将不能产生 RTTI 信息，为什么？)

===============================================================================
⊙ 获取其它数据类型的 RTTI 信息
===============================================================================

上面讨论了几个典型的 RTTI 信息的运行，其它的数据类型的 RTTI信息的获取方法与上面类似。由于这些操作更加简单，就不一一讨论。下面概述其它类型的 RTTI 信息的情况：

LongString、WideString 和 Variant 没有 RTTI 信息；
ShortString 只有 MaxLength 信息；
浮点数类型只有 FloatType: TFloatType 信息；
  TFloatType = (ftSingle, ftDouble, ftExtended,ftComp, ftCurr);
Int64 只有最大值和最小值信息(也是 64 位整数表示)；
Interface 和动态数组不太熟悉，就不作介绍了。