面向对象技术是九十年代的主流技术，各类应用软件如果以面向对象的方法构造并且渗透面向对象的风格将使软件具有更高的品质。在面向对象程序设计中，对象式数据管理占有很重要的地位。在Delphi中，对对象式数据管理的支持方式是其一大特色。
Delphi是一个面向对象的可视化设计与面向对象的语言相结合的集成开发环境。Delphi的核心是部件。部件是对象的一种。Delphi应用程序完全是由部件来构造的，因此开发高性能的Delphi应用程序必然会涉及对象式数据管理技术。
对象式数据管理包括两方面的内容：
● 用对象来管理数据
● 对各类数据对象（包括对象和部件）的管理
Delphi在这两方面都做的相当出色。在Delphi的早期版本Turbo Pascal 中就曾有流(Stream)、群(Collection)和资源(Resource)等专门用于对象式数据管理的类。在Delphi中，这些功能得到了大大的加强。Delphi将对象式数据管理类归结为Stream对象(Stream)和Filer对象(Filer)，并将它们应用于可视部件类库（VCL）的方方面面。它们不仅提供了在内存、外存和Windows资源中管理对象的功能，还提供了在数据库BLOB字段中对象的功能。
在本章中将介绍Stream对象和Filer对象的实现原理、应用方法以及在超媒体系统中的应用。这对于运用Delphi 开发高级应用是很重要的。
20.1 流式对象的实现原理和应用
Stream对象，又称流式对象，是TStream、THandleStream、TFileStream、TMemoryStream、TResourceStream和TBlobStream等的统称。它们分别代表了在各种媒介上存储数据的能力，它们将各种数据类型(包括对象和部件) 在内存、外存和数据库字段中的管理操作抽象为对象方法，并且充分利用了面向对象技术的优点，应用程序可以相当容易地在各种Stream对象中拷贝数据。
下面介绍各种对象的数据和方法及使用方法。
20.1.1 TStream对象
TStream对象是能在各种媒介中存储二进制数据的对象的抽象对象。从TStream 对象继承的对象用于在内存、Windows资源文件、磁盘文件和数据库字段等媒介中存储数据。
TStream中定义了两个属性：Size和Position。它们分别以字节为单位表示的流的大小和当前指针位置。TStream中定义的方法用于在各种流中读、写和相互拷贝二进制数据。因为所有的Stream对象都是从TStream中继承来的，所以在TStream中定义的域和方法都能被Stream对象调用和访问。此外，又由于面向对象技术的动态联编功能，TStream为各种流的应用提供了统一的接口，简化了流的使用；不同Stream对象是抽象了对不同存储媒介的数据上的操作，因此，TStream的需方法为在不同媒介间的数据拷贝提供了最简捷的手段。
20.1.1.1 TStream的属性和方法
1. Position属性
声明：property Position: Longint;
Position属性指明流中读写的当前偏移量。
2. Size属性
声明：property Size: Longint;
Size属性指明了以字节为单位的流的的大小，它是只读的。
3. CopyFrom方法
声明：function CopyFrom(Source: TStream; Count: Longint): Longint;
CopyFrom从Source所指定的流中拷贝Count个字节到当前流中， 并将指针从当前位置移动Count个字节数，函数返回值是实际拷贝的字节数。
4. Read方法
声明：function Read(var Buffer; Count: Longint): Longint; virtual; abstract;
Read方法从当前流中的当前位置起将Count个字节的内容复制到Buffer中，并把当前指针向后移动Count个字节数，函数返回值是实际读的字节数。如果返回值小于Count，这意味着读操作在读满所需字节数前指针已经到达了流的尾部。
Read方法是抽象方法。每个后继Stream对象都要根据自己特有的有关特定存储媒介的读操作覆盖该方法。而且流的所有其它的读数据的方法（如：ReadBuffer，ReadComponent等）在完成实际的读操作时都调用了Read方法。面向对象的动态联编的优点就体现在这儿。因为后继Stream对象只需覆盖Read方法，而其它读操作(如ReadBuffer、ReadComponent等)都不需要重新定义，而且TStream还提供了统一的接口。
5. ReadBuffer方法
声明：procedure ReadBuffer(var Buffer; Count: Longint);
ReadBuffer方法从流中将Count个字节复制到Buffer 中， 并将流的当前指针向后移动Count个字节。如读操作超过流的尾部，ReadBuffer方法引起EReadError异常事件。
6. ReadComponent方法
声明：function ReadComponent(Instance: TComponent): TComponent;
ReadComponent方法从当前流中读取由Instance所指定的部件，函数返回所读的部件。ReadComponent在读Instance及其拥有的所有对象时创建了一个Reader对象并调用它的ReadRootComponent方法。
如果Instance为nil，ReadComponent的方法基于流中描述的部件类型信息创建部件，并返回新创建的部件。
7. ReadComponentRes方法
声明：function ReadComponentRes(Instance: TComponent): TComponent;
ReadComponentRes方法从流中读取Instance指定的部件，但是流的当前位置必须是由WriteComponentRes方法所写入的部件的位置。
ReadComponentRes 首先调用ReadResHeader方法从流中读取资源头，然后调用ReadComponent方法读取Instance。如果流的当前位置不包含一个资源头。ReadResHeader将引发一个EInvalidImage异常事件。在Classes库单元中也包含一个名为ReadComponentRes的函数，该函数执行相同的操作，只不过它基于应用程序包含的资源建立自己的流。
8. ReadResHeader方法
声明：procedure ReadResHeader;
ReadResHeader方法从流的当前位置读取Windows资源文件头，并将流的当前位置指针移到该文件头的尾部。如果流不包含一个有效的资源文件头，ReadResHeader将引发一个EInvalidImage异常事件。
流的ReadComponentRes方法在从资源文件中读取部件之前，会自动调用ReadResHeader方法，因此，通常程序员通常不需要自己调用它。
9. Seek方法
声明：function Seek(Offset: Longint; Origin: Word): Longint; virtual; abstract;
Seek方法将流的当前指针移动Offset个字节，字节移动的起点由Origin指定。如果Offset是负数，Seek方法将从所描述的起点往流的头部移动。下表中列出了Origin的不同取值和它们的含义：
表20.1 函数Seek的参数的取值
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
常量 值 Seek的起点 Offset的取值
─────────────────────────────────
SoFromBeginning 0 流的开头 正 数
SoFromCurrent 1 流的当前位置 正数或负数
SoFromEnd 2 流的结尾 负 数
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
10. Write方法
在Delphi对象式管理的对象中有两类对象的方法都有称为Write的：Stream对象和Filer对象。Stream对象的Write方法将数据写进流中。Filer对象通过相关的流传递数据，在后文中会介绍这类方法。
Stream对象的Write方法声明如下：
function Write(const Buffer; Count: Longint): Longint; virtual; abstract;
Write方法将Buffer中的Count个字节写入流中，并将当前位置指针向流的尾部移动Count个字节，函数返回写入的字节数。
TStream的Write方法是抽象的，每个继承的Stream对象都要通过覆盖该方法来提供向特定存储媒介(内存、磁盘文件等)写数据的特定方法。流的其它所有写数据的方法(如WriteBuffer、WriteComponent)都调用Write担当实际的写操作。
11. WriteBuffer方法
声明：procedure WriteBuffer(const Buffer; Count: Longint);
WriteBuffer的功能与Write相似。WriteBuffer方法调用Write来执行实际的写操作，如果流没能写所有字节，WriteBuffer会触发一个EWriteError异常事件。
12. WriteComponent方法
在Stream对象和Filer对象都有被称为WriteComponent的方法。Stream对象的WriteComponent方法将Instance所指定的部件和它所包含的所有部件都写入流中；Writer对象的WriteComponent将指定部件的属性值写入Writer对象的流中。
Stream对象的WriteComponent方法声明是这样的：
procedure WriteComponent(Instance: Tcomponent);
WriteComponent创建一个Writer对象，并调用Writer的WriteRootComponent方法将Instance及其拥有的对象写入流。
13. WriteComponentRes方法
声明：WriteComponentRes(const ResName: String; Instance: TComponent);
WriteComponentRes方法首先往流中写入标准Windows 资源文件头，然后将Instance指定的部件写入流中。要读由WriteComponentRes写入的部件，必须调用ReadComponentRes方法。
WriteComponentRes使用ResName传入的字符串作为资源文件头的资源名，然后调用WriteComponent方法将Instance和它拥有的部件写入流。
14. WriteDescendant方法
声明：procedure WriteDescendant(Instance Ancestor: TComponent);
Stream对象的WriteDescendant方法创建一个Writer对象，然后调入该对象的WriteDescendant方法将Instance部件写入流中。Instance可以是从Ancestor部件继承的窗体，也可以是在从祖先窗体中继承的窗体中相应于祖先窗体中Ancestor部件的部件。
15. WriteDescendantRes方法
声明：procedure WriteDescendantRes(const ResName: String;
Instance, Ancestor: TComponent);
WriteDescendantRes方法将Windows资源文件头写入流，并使用ResName作用资源名，然后调用WriteDescendant方法，将Instance写入流。
20.1.1.2 TStream的实现原理
TStream对象是Stream对象的基础类，这是Stream对象的基础。为了能在不同媒介上的存储数据对象，后继的Stream对象主要是在Read和Write方法上做了改进，。因此，了解TStream是掌握Stream对象管理的核心。Borland公司虽然提供了Stream对象的接口说明文档，但对于其实现和应用方法却没有提及，笔者是从Borland Delphi 2.0 Client/Server Suite 提供的源代码和部分例子程序中掌握了流式对象技术。
下面就从TStream的属性和方法的实现开始。
1. TStream属性的实现
前面介绍过，TStream具有Position和Size两个属性，作为抽象数据类型，它抽象了在各种存储媒介中读写数据所需要经常访问的域。那么它们是怎样实现的呢？
在自定义部件编写这一章中介绍过部件属性定义中的读写控制。Position和Size也作了读写控制。定义如下：
property Position: Longint read GetPosition write SetPosition;
property Size: Longint read GetSize;
由上可知，Position是可读写属性，而Size是只读的。
Position属性的实现就体现在GetPosition和SetPosition。当在程序运行过程中，任何读取Position的值和给Position赋值的操作都会自动触发私有方法GetPosition和SetPosition。两个方法的声明如下：
function TStream.GetPosition: Longint;
begin
Result := Seek(0, 1);
end;
procedure TStream.SetPosition(Pos: Longint);
begin
Seek(Pos, 0);
end;
在设置位置时，Delphi编译机制会自动将Position传为Pos。
前面介绍过Seek的使用方法，第一参数是移动偏移量，第二个参数是移动的起点，返回值是移动后的指针位置。
Size属性的实现只有读控制，完全屏蔽了写操作。读控制方法GetSize实现如下：
function TStream.GetSize: Longint;
var
Pos: Longint;
begin
Pos := Seek(0, 1);
Result := Seek(0, 2);
Seek(Pos, 0);
end;
2. TStream方法的实现
⑴ CopyFrom方法
CopyFrom是Stream对象中很有用的方法，它用于在不同存储媒介中拷贝数据。例如，内存与外部文件之间、内存与数据库字段之间等。它简化了许多内存分配、文件打开和读写等的细节，将所有拷贝操作都统一到Stream对象上。
前面曾介绍：CopyFrom方法带Source和Count两个参数并返回长整型。该方法将Count个字节的内容从Source拷贝到当前流中，如果Count值为0则拷贝所有数据。
function TStream.CopyFrom(Source: TStream; Count: Longint): Longint;
const
MaxBufSize = $F000;
var
BufSize, N: Integer;
Buffer: PChar;
begin
if Count = 0 then
begin
Source.Position := 0;
CouNG="ZH-CN">资源文件中的部件时调用，通常程序员不需自己调用。如果读取的不是资源文件ReadResHeader，将触发异常事件。
procedure TStream.ReadResHeader;
var
ReadCount: Longint;
Header: array[0..79] of Char;
begin
FillChar(Header, SizeOf(Header), 0);
ReadCount := Read(Header, SizeOf(Header) - 1);
if (Byte((@Header[0])^) = $FF) and (Word((@Header[1])^) = 10) then
Seek(StrLen(Header + 3) + 10 - ReadCount, 1)
else
raise EInvalidImage.CreateRes(SInvalidImage);
end;
ReadComponentRes在Windows资源文件中读取部件，为了判断是否是资源文件，它首先调用ReadResHeader方法，然后调用ReadComponent方法读取Instance指定的部件。下面是它的实现：
function TStream.ReadComponentRes(Instance: TComponent): TComponent;
begin
ReadResHeader;
Result := ReadComponent(Instance);
end;
与ReadComponentRes相应的写方法是WriteComponentRes，Delphi 调用这两个方法读写窗体文件(DFM文件)，在后面书中会举用这两个方法读取DFM文件的例子。
⑷ WriteComponent和WriteDescendant方法
Stream对象的WriteDescendant方法在实现过程中，创建了TWriter对象，然后利用TWriter的WriteDescendant方法将Instance写入流。而WriteComponent方法只是简单地调用WriteDescendant方法将Instance写入流。它们的实现如下：
procedure TStream.WriteComponent(Instance: TComponent);
begin
WriteDescendent(Instance, nil);
end;
procedure TStream.WriteDescendent(Instance, Ancestor: TComponent);
var
Writer: TWriter;
begin
Writer := TWriter.Create(Self, 4096);
try
Writer.WriteDescendent(Instance, Ancestor);
finally
Writer.Free;
end;
end;
⑸ WriteDescendantRes和WriteComponentRes方法
WriteDescendantRes方法用于将部件写入Windows资源文件；而WriteComponentRes 方法只是简单地调用WriteDescendantRes方法，它们的实现如下：
procedure TStream.WriteComponentRes(const ResName: string; Instance:
TComponent);
begin
WriteDescendentRes(ResName, Instance, nil);
end;
procedure TStream.WriteDescendentRes(const ResName: string; Instance,
Ancestor: TComponent);
var
HeaderSize: Integer;
Origin, ImageSize: Longint;
Header: array[0..79] of Char;
begin
Byte((@Header[0])^) := $FF;
Word((@Header[1])^) := 10;
HeaderSize := StrLen(StrUpper(StrPLCopy(@Header[3], ResName, 63))) + 10;
Word((@Header[HeaderSize - 6])^) := $1030;
Longint((@Header[HeaderSize - 4])^) := 0;
WriteBuffer(Header, HeaderSize);
Origin := Position;
WriteDescendent(Instance, Ancestor);
ImageSize := Position - Origin;
Position := Origin - 4;
WriteBuffer(ImageSize, SizeOf(Longint));
Position := Origin + ImageSize;
end;
WriteCompnentRes是与ReadComponentRes相应的对象写方法，这两个方法相互配合可读取Delphi的DFM文件，从而利用Delphi系统的功能。
20.1.2 THandleStream对象
THandleStream对象的行为特别象FileStream对象，所不同的是它通过已创建的文件句柄而不是文件名来存储流中的数据。
THandleStream对象定义了Handle属性，该属性提供了对文件句柄的只读访问，并且Handle属性可以作为Delphi的RTL文件管理函数的参数，利用文件类函数来读写数据。THandleStream覆盖了构造函数Create，该函数带有Handle 参数，该参数指定与THandleStream对象相关的文件句柄。
20.1.2.1 THandleStream的属性的方法：
1. Handle属性
声明：property Handle: Integer;
Handle属性提供了对文件句柄的只读访问，该句柄由THandleStream的构造方法Create传入。因此除了用THandleStream提供的方法外，也可以用文件管理函数对句柄进行操作。实际上，THandleStream的方法在实现上也是运用文件管理函数进行实际的读写操作。
2. Create方法
声明：constructor Create(AHandle: Integer);
Create方法使用传入的Handle参数创建一个与特定文件句柄相联的THandleStream对象，并且将AHandle赋给流的Handle属性。
3. Read、Write和Seek方法
这三个方法是TStream的虚方法，只是在THandleStream 中覆盖了这三个方法，以实现特定媒介──文件的数据存取。后面会详细介绍这三个方法的实现。
20.1.2.2 THandleStream的实现原理
THandleStream是从TStream继承来的，因此可以共用TStream中的属性和大多数方法。THandleStream在实现上主要是增加了一个属性Handle和覆盖了Create、Read、Write和Seek四个方法。
1. 属性的实现
Handle属性的实现正如Delphi大多数属性的实现那样，先在对象定义的private部分声明一个存放数据的变量FHandle，然后在定义的public部分声明属性Handle，其中属性定义的读写控制部分加上只读控制，读控制只是直接读取FHandle变量的值，其实现如下：
THandleStream = class(TStream)
private
FHandle: Integer;
public
…
property Handle: Integer read FHandle;
end;
2. 方法的实现
THandleStream的Create方法，以AHandle作为参数，在方法里面只是简单的将AHandle的值赋给FHandle，其实现如下：
constructor THandleStream.Create(AHandle: Integer);
begin
FHandle := AHandle;
end;
为实现针对文件的数据对象存储，THandleStream的Read、Write和Seek方法覆盖了TStream中的相应方法。它们的实现都调用了Windows的文件管理函数。
Read方法调用FileRead函数实现文件读操作，其实现如下：
function THandleStream.Read(var Buffer; Count: Longint): Longint;
begin
Result := FileRead(FHandle, Buffer, Count);
if Result = -1 then Result := 0;
end;
Write方法调用FileWrite函数实现文件写操作，其实现如下：
function THandleStream.Write(const Buffer; Count: Longint): Longint;
begin
Result := FileWrite(FHandle, Buffer, Count);
if Result = -1 then Result := 0;
end;
Seek方法调用FileSeek函数实现文件指针的移动，其实现如下：
function THandleStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
Result := FileSeek(FHandle, Offset, Origin);
end;
20.1.3 TFileStream对象
TFileStream对象是在磁盘文件上存储数据的Stream对象。TFileStream是从THandleStream继承下来的，它和THandleStream一样都是实现文件的存取操作。不同之处在于THandleStream用句柄访问文件，而TFileStream用文件名访问文件。实际上TFileStream是THandleStream上的一层包装，其内核是THandleStream的属性和方法。
TFileStream中没有增加新的属性和方法。它只是覆盖了的构造方法Create和析构方法Destory。在Create方法中带两个参数FileName和Mode。FileName描述要创建或打开的文件名，而Mode描述文件模式如fmCreate、fmOpenRead和fmOpenWrite等。Create方法首先使用FileCreate或FileOpen函数创建或打开名为FileName的文件，再将得到的文件句柄赋给FHandle。TFileStream的文件读写操作都是由从THandleStream继承的Read< P>
var
Stream: TStream;
begin
Stream := TFileStream.Create(FileName, fmCreate);
try
SaveToStream(Stream);
finally
Stream.Free;
end;
end;
在Delphi 的许多对象的SaveToStream 和SaveToFile、LoadFromStream和LoadFromFile方法的实现都有类似的嵌套结构。
20.1.5 TMemoryStream对象
TMemoryStream对象是一个管理动态内存中的数据的Stream对象，它是从TCustomMemoryStream中继承下来的，除了从TCustomMemoryStream中继承的属性和方法外，它还增加和覆盖了一些用于从磁盘文件和其它注台读数据的方法。它还提供了写入、消除内存内容的动态内存管理方法。下面介绍它的这些属性和方法。
20.1.5.1 TMemoryStream的属性和方法
1. Capacity属性
声明：property Copacity: Longint;
Capacity属性决定了分配给内存流的内存池的大小。这与Size属性有些不同。Size属性是描述流中数据的大小。在程序中可以将Capacity 的值设置的比数据所需最大内存大一些，这样可以避免频繁地重新分配。
2. Realloc方法
声明：function Realloc(var NewCapacity: Longint): Pointer; virtual;
Realloc方法，以8K为单位分配动态内存，内存的大小由NewCapacity指定，函数返回指向所分配内存的指针。
3. SetSize方法
SetSize方法消除内存流中包含的数据，并将内存流中内存池的大小设为Size字节。如果Size为零，是SetSize方法将释放已有的内存池，并将Memory属性置为nil；否则，SetSize方法将内存池大小调整为Size。
4. Clear方法
声明：procedure Clear;
Clear方法释放内存中的内存池，并将Memory属性置为nil。在调用Clear方法后，Size和Position属性都为0。
5. LoadFromStream方法
声明：procedure LoadFromStream(Stream: TStream);
LoadFromStream方法将Stream指定的流中的全部内容复制到MemoryStream中，复制过程将取代已有内容，使MemoryStream成为Stream的一份拷贝。
6. LoadFromFile方法
声明：procedure LoadFromFile(count FileName: String);
LoadFromFile方法将FileName指定文件的所有内容复制到MemoryStream中，并取代已有内容。调用LoadFromFile方法后，MemoryStream将成为文件内容在内存中的完整拷贝。
20.1.5.2 TMemoryStream对象的实现原理
TMemoryStream从TCustomMemoryStream对象直接继承，因此可以享用TCustomMemoryStream的属性和方法。前面讲过，TCustomMemoryStream是用于内存中数据操作的抽象对象，它为MemoryStream对象的实现提供了框架，框架中的内容还要由具体MemoryStream对象去填充。TMemoryStream对象就是按动态内存管理的需要填充框架中的具体内容。下面介绍TMemoryStream对象的实现。
1. TMemoryStream属性的实现
TMemoryStream在其protected部分增加了一个Capacity属性，该属性决定了MemoryStream所占动态内存的大小。TMemoryStream首先在private部分声明了FCapacity变量作为存储Capacity属性值的数据域，然后在protected部分声明了该属性。在属性声明的读控制部分简单读取FCapacity的值，在写控制处调用了方法SetCapacity。该方法除了给FCapacity赋值外还执行了修改Capacity属性所必需操作如状态改变等。
下面是属性的实现：
TMemoryStream = class(TCustomMemoryStream)
private
FCapacity: Longint;
procedure SetCapacity(NewCapacity: Longint);
protected
…
property Capacity: Longint read FCapacity write SetCapacity;
public
…
end;
写控制方法SetCapacity的实现是这样的：
procedure TMemoryStream.SetCapacity(NewCapacity: Longint);
begin
SetPointer(Realloc(NewCapacity), FSize);
FCapacity := NewCapacity;
end;
在SetCapacity 方法先是调用Realloc重新分配内存，然后用NewCapacity的值给FCapacity赋值。Realloc方法进行某些对象状态的改变。
2. TMemoryStream对象方法的实现
⑴ Realloc方法
Realloc方法是TMemoryStream动态内存分配的核心，它的SetSize、SetCapacity等方法最终都是调用Realloc进行内存的分配和初始化工作的。它的实现如下：
const
MemoryDelta = $2000;
function TMemoryStream.Realloc(var NewCapacity: Longint): Pointer;
begin
if NewCapacity > 0 then
NewCapacity := (NewCapacity + (MemoryDelta - 1)) and not (MemoryDelta - 1);
Result := Memory;
if NewCapacity <> FCapacity then
begin
if NewCapacity = 0 then
begin
GlobalFreePtr(Memory);
Result := nil;
end else
begin
if Capacity = 0 then
Result := GlobalAllocPtr(HeapAllocFlags, NewCapacity)
else
Result := GlobalReallocPtr(Memory, NewCapacity, HeapAllocFlags);
if Result = nil then raise EStreamError.CreateRes(SMemoryStreamError);
end;
end;
end;
Realloc方法是以8K为单位分配动态内存的，方法中的第一句if语句就是执行该操作。如果传入的NewCapacity参数值为0，则释放流中的内存。Realloc方法用GLobal FreePtr函数释放内存，用GlobalAllocPtr分配内存，用GlobalReallocPtr进行内存的重分配。如果原来的Capacity属性值为0，则调用Globa|AllocPtr否则调用GlobalReallocPtr。最后如果Result为nil则触发内存流错的异常事件，否则返回指向分配的内存的指针。
⑵ Write方法
Write方法从内存流内部缓冲池的当前位置开始写入二进制数据。其实现如下：
function TMemoryStream.Write(const Buffer; Count: Longint): Longint;
var
Pos: Longint;
begin
if (FPosition >= 0) and (Count >= 0) then
begin
Pos := FPosition + Count;
if Pos > 0 then
begin
if Pos > FSize then
begin
if Pos > FCapacity then
SetCapacity(Pos);
FSize := Pos;
end;
System.Move(Buffer, Pointer(Longint(FMemory) + FPosition)^, Count);
FPosition := Pos;
Result := Count;
Exit;
end;
end;
Result := 0;
end;
Buffer中存储要写入流的二进制数据，如果要写入的数据的字节超出了流的内存池的大小，则调用SetCapacity方法再分配内存，然后用内存复制函数将Buffer中的数据复制到FMemory中。接着移动位置指针，并返回写入数据的字节数。分析这段程序可以知道，FCapacity的值和FSize的值是不同的。
⑶ Clear方法
Clear方法消除内存流中的数据，将Memory属性置为nil，并将FSize和FPosition 的值设为0。其实现如下：
procedure TMemoryStream.Clear;
begin
SetCapacity(0);
FSize := 0;
FPosition := 0;
end;
⑷ LoadFromStream和LoadFromFile方法
LoadFromStream方法首先根据传入的Stream的Size属性值重新分配动态内存，然后调用Stream的ReadBuffer方法往FMemory中复制数据，结果Stream的全部内容在内存中有了一份完整拷贝。其实现如下：
procedure TMemoryStream.LoadFromStream(Stream: TStream);
var
Count: Longint;
begin
Stream.Position := 0;
Count := Stream.Size;
SetSize(Count);
if Count <> 0 then Stream.ReadBuffer(FMemory^, Count);
end;
LoadFromFile与LoadFromStream是一对方法。LoadFromFile首先创建了一个TFileStream对象，然后调用LoadFromStream方法，将FileStream文件流中的数据写入MemoryStream中。
20.1.6 TResourceStream对象
TResourceStream对象是另一类MemoryStream对象，它提供对Windows 应用程序资源的访问，因此称它为资源流。TResourceSream也是从TCustomMemoryStream 继承的。因此在TCustomMemoryStream对象的基础上，定义了与指定资源模块或资源文件建立连接的构造方法，并且还覆盖了Write，以实现向资源文件中写数据。
下面介绍TResourceStream的实现
1. 私有域
TResourceStream没有定义新的属性，但它在private部分定义了两个数据域HResInfo和HGlobol和一个私有方法Initialize，它们的定义如下：
TResourceStream = class(TCustomMemoryStream)
private
HResInfo: HRSRC;
HGlobal: THandle;
procedure Initialize(Instance: THandle; Name, ResType: PChar);
…
end;
HRSRC是描述Windows资源信息的结构句柄。HGlobal变量代表资源所在模块的句柄。如果操作的是应用程序资源，HGlohal就代表EXE程序的句柄；如果是动态链接库（DLL），则HGlobal 代表动态链接库的句柄。TResourceStream对象使用这两上变量访问应用程序或动态链接库中的资源。
Initialize方法是TResourceStream对象内部使用的。它的构造方法Create和CreateFromID都是调用Initialize方法完成对TResourceStream的初始化。它的实现如下：
procedure TResourceStream.Initialize(Instance: THandle; Name, ResType: PChar);
procedure Error;
begin
raise EResNotFound.Create(FmtLoadStr(SResNotFound, [Name]));
end;
begin
HResInfo := FindResource(Instance, Name, ResType);
if HResInfo = 0 then Error;
HGlobal := LoadResource(Instance, HResInfo);
if HGlobal = 0 then Error;
SetPointer(LockResource(HGlobal), SizeOfResource(Instance, HResInfo));
end;
该方法实现中，首先调用Windows函数FoundResource得到由参数Instance指定的模块中的名为Name和类型为ResType的资源，然后调用LoadResource将资源调用内存，并返回该资源在内存中的句柄，最后，将该资源复制到ResourceStream中。方法的Instance参数代表要调用的资源所在的模块句柄。模块可以是可执行文件，也可以是动态链接库。如果在读取资源时没在模块中发现要找的资源则产生异常事件。
2. 构造方法Create和CreateFromID
这两个方法在实现上没有大的不同。顾名思义，第一个方法是通过资源名构造TResourceStream; 第二个方法通过资源ID构造TResourceStream，而且在实现过程中，它们都调用了Initialize方法。下面是它们的实现：
constructor TResourceStream.Create(Instance: THandle; const ResName: string;
ResType: PChar);
begin
inherited Create;
Initialize(Instance, PChar(ResName), ResType);
end;
constructor TResourceStream.CreateFromID(Instance: THandle; ResID: Integer;
ResType: PChar);
begin
inherited Create;
Initialize(Instance, PChar(ResID), ResType);
end;
这两个方法中都有Instance参数，该参数值的含义在Insitialize中介绍过。
3. Write方法
TResourceStream的Write方法只完成一件事，就产生这个异常事件，其实现如下：
function TResourceStream.Write(const Buffer; Count: Longint): Longint;
begin
raise EStreamError.CreateRes(SCantWriteResourceStreamError);
end;
从方法实现中可以看到，TSourceStream对象是不允许写数据的。一旦往资源流中写数据将产生异常事件。
4. 析构方法Destroy
该方法产生给资源解锁，然后释放该资源，最后调用继承的Destroy方法释放ResourceStream。其实现如下：
destructor TResourceStream.Destroy;
begin
UnlockResource(HGlobal);
FreeResource(HResInfo);
inherited Destroy;
end;
回顾Initialize方法，我们不难发现：
● ResourceStream没有额外地给资源重新分配内存，而是直接使用HGlobal句柄所指 的内存域
● ResourceStream中的资源在流的生存期，始终是Lock状态，因此要根据Windows 的内存使用规则合理安排ResourceStream的使用
● ResourceStream只是用于访问应用程序和动态链接库中的资源的
在Classes在单元中提供了InternalReadComponentRes函数，该函数使用了TResourceStream对象从Delphi应用程序中读取部件。Delphi是将窗体和部件信息放在模块资源的RCDATA段的。
20.1.7 TBlobStream对象
从Delphi 数据库开发平台这个意义上说，TBlobStream 对象是个很重要的对象。TBlobStream对象提供了修改TBlobField、TBytesField或TVarBytesField中数据的技术。开发者可以象对待文件或流那样在数据库域中读写数据。
传统数据库发展的一个重要趋向是往多媒体数据库发展。目前比较著名和流行的数据库都支持多媒体功能，多媒体数据存储中的一大难点是数据结构不规则，数据量大。各大数据库产品是采用BLOB技术解决多媒体数据存储中的问题。Delphi的TBlobStream对象的意义就在于：一方面可以使Delphi应用程序充分利用多媒体数据库的数据管理能力；另一方面又能利用Object Pascal的强大程序设计能力给多媒体数据库提供全方向的功能扩展余地。
使用TBlobStream对象可以在多媒体数据库的BLOB字段存储任意格式的数据。一般说来，许多多媒体数据库只能支持图像、语音或者OLE服务器支持的数据。利用TBlobStream则不同，只要是程序能够定义的数据格式，它都能在BLOB字段中读写，而不需要其它辅助工具。
TBlobStream用构造方法Create建立数据库域和BLOB流的联接。用Read或Write 方法访问和改变域中的内容；用Seek方法，在域中定位；用Truncate方法删除域中当前位置起所有的数据。
20.1.7.1 TBlobStream的属性和方法
TBlobStream对象从TStream直接继承，没有增添新的属性。它覆盖了Read、Write 和Seek方法，提供了对BLOB字段的访问操作；它增添了Truncate方法以实现BLOB字段中的删除操作。
1. Read方法
声明：function Read(var Buffer; Count: Longint): Longint;
Read方法从数据库域的当前位置起复制Count个字节的内容到Buffer中。Buffer也必须至少分配Count个字节。Read方法返回实际传输的字节数，因为传输的字节数可能小于Count，所以需要选择符的边界判断。
2. Write方法
声明：function Write(const Buffer; Count: Longint); override; Longint;
Write方法从Buffer中向数据库域的当前位置复制Count个字节的内容。Buffer必须分配有Count个字节的内存空间，函数返回实际传输的字节数，传输过程也要进行选择符边界判断。
3. Seek方法
声明：function Seek(Offset: Longint; Origin: Word): Longint;
Seek方法重新设置BLOB流中的指针位置。如果Origin的值是soFromBeginning，则新的指针位置是Offset; 如Origin的值是soFromCurrent，则新的指针位置是Position+Offset；如果Origin的值是SoFromCurrent，则新的指针位置是Size+Offset。函数返回新的指针位置值。当Origin为0(SoFromBegin)时，Offset的值必须大于等于零; 当Origin的值为2(SoFromEnd)，Offset的值必须小于等于零。
4. Truncate方法
声明：procedure Truncate;
Truncate方法撤消TBlobField、TBytesField或TVarBytesField中从当前位置起的数据。
5. Create方法
声明：constructor Create(Field: TBlobField; Mode: TBlobStreamMode);
Create方法使用Field参数建立BLOB流与BLOB字段的联接。Mode 的值可为bmRead、bmWrite和bmReadWrite。
20.1.7.2 TBlobStream的实现原理
说明TBlobStream对象的实现原理，不可避免地要涉及它的私有域，下面是私有域的定义：
TBlobStream = class(TStream)
private
FField: TBlobField;
FDataSet: TDataSet;
FRecord: PChar;
FBuffer: PChar;
FFieldNo: Integer;
FOpened: Boolean;
FModified: Boolean;
FPosition: Longint;
…
public
…
end;
FField是与BLOB流相联的数据库BLOB域，该域用于BLOB流的内部访问。FDataSet是代表FField所在的数据库，它可以是TTable部件，也可以是TQuery 部件。FRecord和FBuffer都是BLOB流内部使用的缓冲区，用于存储FField所在记录的数据，该数据记录中不包含BLOB数据，TBlobStream使用FRecord作为调用BDE API函数的参数值。FFieldNo代表BLOB字段的字段号，也用于BDE API的参数传递，FOpened和FMocified都是状态信息，FPosition表示BLOB流的当前位置，下面介绍TBlobStream方法实现。
1. Create方法和Destroy方法的实现
Create方法的功能主要是建立BlobStream流与BLOB字段的联系并初始化某些私有变量。其实现如下：
constructor TBlobStream.Create(Field: TBlobField; Mode: TBlobStreamMode);
var
OpenMode: DbiOpenMode;
begin
FField := Field;
FDataSet := Field.DataSet;
FRecord := FDataSet.ActiveBuffer;
FFieldNo := Field.FieldNo;
if FDataSet.State = dsFilter then
DBErrorFmt(SNoFieldAccess, [FField.DisplayName]);
if not FField.FModified then
begin
if Mode = bmRead then
begin
FBuffer := AllocMem(FDataSet.RecordSize);
FRecord := FBuffer;
if not FDataSet.GetCurrentRecord(FBuffer) then Exit;
OpenMode := dbiReadOnly;
end else
begin
if not (FDataSet.State in [dsEdit, dsInsert]) then DBError(SNotEditing);
OpenMode := dbiReadWrite;
end;
Check(DbiOpenBlob(FDataSet.Handle, FRecord, FFieldNo, OpenMode));
end;
FOpened := True;
if Mode = bmWrite then Truncate;
end;
该方法首先是用传入的Field参数给FField，FDataSet，FRecord和FFieldNo赋值。方法中用AllocMem按当前记录大小分配内存，并将指针赋给FBuffer，用DataSet部件的GetCurrentRecord方法，将记录的值赋给FBuffer，但不包括BLOB数据。
方法中用到的DbiOpenBlob函数是BDE的API函数，该函数用于打开数据库中的BLOB字段。
最后如果方法传入的Mode参数值为bmWrite，就调用Truncate将当前位置指针以后的
数据删除。
分析这段源程序不难知道：
● 读写BLOB字段，不允许BLOB字段所在DataSet部件有Filter，否则产生异常事件
● 要读写BLOB字段，必须将DataSet设为编辑或插入状态
● 如果BLOB字段中的数据作了修改，则在创建BLOB 流时，不再重新调用DBiOpenBlob函数，而只是简单地将FOpened置为True，这样可以用多个BLOB 流对同一个BLOB字段读写
Destroy方法释放BLOB字段和为FBuffer分配的缓冲区，其实现如下：
destructor TBlobStream.Destroy;
begin
if FOpened then
begin
if FModified then FField.FModified := True;
if not FField.FModified then
DbiFreeBlob(FDataSet.Handle, FRecord, FFieldNo);
end;
if FBuffer <> nil then FreeMem(FBuffer, FDataSet.RecordSize);
if FModified then
try
FField.DataChanged;
except
Application.HandleException(Self);
end;
end;
如果BLOB流中的数据作了修改，就将FField的FModified置为True；如果FField的Modified为False就释放BLOB字段，如果FBuffer不为空，则释放临时内存。最后根据FModified的值来决定是否启动FField的事件处理过程DataChanged。
不难看出，如果BLOB字段作了修改就不释放BLOB字段，并且对BLOB 字段的修改只有到Destroy时才提交，这是因为读写BLOB字段时都避开了FField，而直接调用BDE API函数。这一点是在应用BDE API编程中很重要，即一定要修改相应数据库部件的状态。
2. Read和Write方法的实现
Read和Write方法都调用BDE API函数完成数据库BLOB字段的读写，其实现如下：
function TBlobStream.Read(var Buffer; Count: Longint): Longint;
var
Status: DBIResult;
begin
Result := 0;
if FOpened then
begin
Status := DbiGetBlob(FDataSet.Handle, FRecord, FFieldNo, FPosition,
Count, @Buffer, Result);
case Status of
DBIERR_NONE, DBIERR_ENDOFBLOB:
begin
if FField.FTransliterate then
NativeToAnsiBuf(FDataSet.Locale, @Buffer, @Buffer, Result);
Inc(FPosition, Result);
end;
DBIERR_INVALIDBLOBOFFSET:
{Nothing};
else
DbiError(Status);
end;
end;
end;
Read方法使用了BDE API的DbiGetBlob函数从FDataSet中读取数据，在本函数中，各参数的含义是这样的：FDataSet.Handle代表DataSet的BDE句柄，FReacord表示BLOB字段所在记录，FFieldNo表示BLOB字段号，FPosition表示要读的的数据的起始位置，Count表示要读的字节数，Buffer是读出数据所占的内存，Result是实际读出的字节数。该BDE函数返回函数调用的错误状态信息。
Read方法还调用了NativeToAnsiBuf进行字符集的转换。
function TBlobStream.Write(const Buffer; Count: Longint): Longint;
var
Temp: Pointer;
begin
Result := 0;
if FOpened then
begin
if FField.FTransliterate then
begin
GetMem(Temp, Count);
try
AnsiToNativeBuf(FDataSet.Locale, @Buffer, Temp, Count);
Check(DbiPutBlob(FDataSet.Handle, FRecord, FFieldNo, FPosition,
Count, Temp));
finally
FreeMem(Temp, Count);
end;
end else
Check(DbiPutBlob(FDataSet.Handle, FRecord, FFieldNo, FPosition,
Count, @Buffer));
Inc(FPosition, Count);
Result := Count;
FModified := True;
end;
end;
Write方法调用了BDE API的DbiPutBlob函数实现往数据库BLOB字段存储数据。
该函数的各参数含义如下：
表20.2 调用函数DbiPutBlob的各传入参数的含义
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
参数名 含义
──────────────────────────────
FDataSetHandle 写入的数据库的BDE句柄
FRecord 写入数据的BLOB字段所在的记录
FFieldNo BLOB字段号
FPosition 写入的起始位置
Count 写入的数据的字节数
Buffer 所写入的数据占有的内存地址
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
方法中还根据FField和FTransliterate的值判断是否进行相应的字符集转换，最后移动BLOB流的位置指针，并将修改标志FModified置为True。
3. Seek和GetBlobSize方法的实现
Seek方法的功能主要是移动BLOB流的位置指针。GetBlobSize方法是私有的，在Seek方法中被调用，其功能是得到BLOB数据的大小。它们的实现如下：
function TBlobStream.GetBlobSize: Longint;
begin
Result := 0;
if FOpened then
Check(DbiGetBlobSize(FDataSet.Handle, FRecord, FFieldNo, Result));
end;
function TBlobStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
case Origin of
0: FPosition := Offset;
1: Inc(FPosition, Offset);
2: FPosition := GetBlobSize + Offset;
end;
Result := FPosition;
end;
GetBlobSize调用了BDE API的DbiGetBlobSize函数，该函数的参数的含义同前面的API函数相同。
4. Truncate方法
该方法是通过调用BDE API函数实现的。其实现如下：
procedure TBlobStream.Truncate;
begin
if FOpened then
begin
Check(DbiTruncateBlob(FDataSet.Handle, FRecord, FFieldNo, FPosition));
FModified := True;
end;
end;
该方法从BLOB流的当前位置起删除所有数据，并设置修改标志FModified为True。在Delphi VCL中许多部件特别是数据库应用方面的部件都用BDE API函数完成对数据库的访问，如Data Access和Data Control部件。各种数据库部件都是BDE API函数外层的包装简化了对数据库的访问操作。BDE API中还提供了避开BDE配置工具在程序中直接处理Alias(建立、修改、删除等)的函数支持，这也是部件所没有提供的。在Delphi数据库应用安装程序中，这些Alias操作函数无疑是相当重要的。有关BDE API函数的详细介绍，可阅读Delphi2.0 Client/Server Suite所带的BDE API 帮助文件。
20.2 读写对象的实现原理和应用
读写对象（Filer）包括TFiler对象、TReader对象和TWriter对象。TFiler对象是文件读写的基础对象，在应用程序中使用的主要是TReader和TWriter。TReader和TWriter对象都直接从TFiler对象继承。TFiler对象定义了Filer对象的基本属性和方法。
Filer对象主要完成两大功能：
● 存取窗体文件和窗体文件中的部件
● 提供数据缓冲，加快数据读写操作
20.2.1 TFiler对象
TFiler对象是TReader和TWriter的抽象类，定义了用于部件存储的基本属性和方法。它定义了Root属性，Root指明了所读或写的部件的根对象，它的Create方法将Stream对象作为传入参数以建立与Stream对象的联系， Filer对象的具体读写操作都是由Stream对象完成。因此，只要是Stream对象所能访问的媒介都能由Filer对象存取部件。TFiler 对象还提供了两个定义属性的方法：DefineProperty和DefineBinaryProperty，这两个方法使对象能读写不在部件published部分定义的属性。
因为Filer对象主要用于存取Delphi的窗体文件和窗体文件中的部件，所以要清楚地理解Filer对象就要清楚Delphi 窗体文件(DFM文件)的结构。
DFM文件是用于Delphi存储窗体的。窗体是Delphi可视化程序设计的核心。窗体对应Delphi应用程序中的窗口，窗体中的可视部件对应窗口中的界面元素，非可视部件如TTable和TOpenDialog，对应Delphi应用程序的某项功能。Delphi应用程序的设计实际上是以窗体的设计为中心。因此，DFM文件在Delphi应用设计中也占很重要的位置。窗体中的所有元素包括窗体自身的属性都包含在DFM文件中。
在Delphi应用程序窗口，界面元素是按拥有关系相互联系的，因此树状结构是最自然的表达形式；相应地，窗体中的部件也是按树状结构组织；对应在DFM文件中，也要表达这种关系。DFM文件在物理上，是以二进制方式存储的，在逻辑上则是以树状结构安排各部件的关系。Delphi编辑窗口支持以文本方式显示DFM文件。从该文本中可以看清窗体的树状结构。下面是DFM文件的文本显示：
Object Form1: TForm1
Left = 72
Top = 77
ActiveControl = DBIMage1
…
Object Panell: TPanel
Left = 6
…
Object DBLabel1: TDBText
…
end
Object DBImage1: TDBImage
…
end
end
Object Panel2: TPanel
Left = 6
…
Object Label1: TLable
…
end
end
Object Panel3: TPanel
Left = 6
…
Object DBLabel2: TDBText
…
end
end
end
关于DFM文件中存储属性值的规则，请参见自定义部件开发这一章。
对照TFiler对象的属性。Root属性就表示部件树的根──窗体。Filer对象的许多方法都是读从根起始的树中所有的部件。Ancestor属性表示根的祖先对象，IgnoreChildren属性则是读部件时忽略根的子结点。
下面介绍Filer对象的属性和方法。
20.2.1.1 TFiler对象的属性和方法
1. Root属性
声明：property Root: TComponent;
Root 属性给Filer对象指出被读写的对象中哪一个对象是根或主要拥有者。RootComponent和WriteRootComponent方法在读和写部件及其拥有的部件前先设置Root的值。
2. Ancestor属性
声明：property Ancestor: TPersistent;
Ancestor属性用于往继承下来的窗体中写部件，因为当写部件时，Write对象只需要写入与所继承的部件不同的属性，所以在写之前要跟踪每个继承的部件，并且比较它们的属性。
如果Ancestor为nil，就表示没有相应的继承的部件，Writer对象应当将部件完全写入流。Ancestor一般为nil，只有当调用WriteDescendant和WriteDescendantRes时，才给赋值。当编写和覆盖DefineProperties时，必须设置Ancestor的值。
3. IgnoreChildren属性
声明：property Ignorechildren: Boolean;
IgnoreChildren属性使一个Writer对象存储部件时可以不存储该部件拥有的部件。如果IgnoreChildren属性为True，则Writer对象存储部件不存它拥有的子部件。否则，Writer对象将所有其拥有的对象写入流。
4. Create方法
声明：constructor Create(Stream: TStream; BufSize: Cardinal);
Create方法创建一个新的Filer对象，建立它和流Stream的联系；并且给它分配一个缓冲区Buffer。Buffer的大小由BufSize指定。
5. Defineproperty方法
声明：procedure Defineproperty(const Name: String; ReadData: TReaderProc;
WriteData: TWriterProc; HasData: Boolean); virtual; abstract;
Defineproperty方法定义Filer对象将作为属性存储的数据。Name参数描述接受的属性名，该属性不在published部分定义。ReadData和WriteData参数指定在存取对象时读和写所需数据的方法。HasData参数在运行时决定了属性是否有数据要存储。
只有当对象有数据要存储时，才在该对象的DefineProperties中调用DefineProperty。DefineProperties有一个Filer对象作为它的参数，调用的就是该Filer对象的DefineProperty和DefineBinaryProperty方法。当定义属性时，Writer对象应当引用Ancestor属性，如果该属性非空，Writer对象应当只写入与从Ancestor继承的不同的属性的值。
一个最简单的例子是TComponent的DefineProperties方法。尽管TComponent 没有在published中定义Left、Top属性，但该方法存储了部件的位置信息。
procedure TComponent.DefineProperties(Filer: TFiler);
begin
Filer.DefineProperty('Left', ReadLeft, WriteLeft, LongRec(FDesignInfo).Lo <> 0);
Filer.DefineProperty('Top', ReadTop, WriteTop, LongRec(FDesignInfo).Hi <> 0);
end;
6. DefineBinaryproperty方法
声明：procedure DefineBinaryproperty(const Name: String;
ReadData, WriteData: TStreamProc;
HisData: Boolean); virtual; abstract;
DefineBinaryProperty方法定义Filer对象作为属性存储的二进制数据。Name参数描述属性名。ReadData和WriteData参数描述所存储的对象中读写所需数据的方法。HasData参数在运行时决定属性是否有数据要存。
DefineBinaryProperty和DefineProperty方法的不同之处在于，二进制型的属性直接用Stream对象读写，而不是通过Filer对象。通过ReadData和WriteData传入的方法，直接将对象数据写入流或从流读出。
DefineBinaryProperty属性用得较少。只有标准的VCL对象定义了象图形、图像之类的二进制属性的部件中才用它。
7. FlushBuffer方法
声明：procedure FlushBuffer; virtual: abstract;
FlushBuffer方法用于使Filer对象的缓冲区与相联的Stream对象同步。对Reader对象来说，是通过重新分配缓冲区；对于Writer对象是通过写入当前缓冲区。
FlushBuffer是一个抽象方法，TReader和TWriter都覆盖了它，提供了具体实现。
20.2.1.2 TFiler对象的实现原理
TFiler对象是Filer对象的基础类，它定义的大多数方法都是抽象类型的，没有具体实现它，这些方法要在TReader和TWrite中覆盖。但它们提供了Filer对象的框架，了解它无疑是很重要的。
1. TFiler对象属性的实现
TFiler对象定义了三个属性：Root、Ancestor和IgnoreChildren。正如定义对象属性通常所采用的方法那样，要在private部分定义存储属性值的数据域，然后在public或Published部分定义该属性，并按需要增加读写控制。它们的定义如下：
TFiler = class(TObject)
private
…
FRoot: TComponent;
FAncestor: TPersistent;
FIgnoreChildren: Boolean;
public
…
property Root: TComponent read FRoot write FRoot;
property Ancestor: TPersistent read FAncestor write FAncestor;
property IgnoreChildren: Boolean read FIgnoreChildren write FIgnoreChildren;
end;
它们在读写控制上都是直接读写私有的数据域。
在介绍TReader和TWriter的实现，我们还会看到这几个属性的原理介绍。
2. TFiler对象方法的实现
在TFiler对象定义的众多方法中很多都是抽象类方法，没有具体实现。在TFiler 的后继对象TReader中覆盖了这些方法。在后面章节，会介绍这些方法的实现。
在TFiler对象中有具体实现的有两个方法Create和Destroy。
⑴ Create方法的实现
Create方法是TFiler的构造方法，它有两个参数Stream和BufSize。Stream是指定与TFiler对象相联系的Stream对象，Filer对象都是用Stream对象完成具体的读写。BufSize是TFiler对象内部开设的缓冲区的大小。Filer对象内部开设缓冲区是为了加快数据的读写，它的实现如下：
constructor TFiler.Create(Stream: TStream; BufSize: Integer);
begin
FStream := Stream;
GetMem(FBuffer, BufSize);
FBufSize := BufSize;
end;
FStream、FBuffer和FBufSize都是TFiler在private部分定义的数据域。FStream表示与Filer对象相联的Stream对象，FBuffer指向Filer对象内部开设的缓冲区，FBufSize是内部缓冲区的大小。Create方法用Stream参数值给FStream赋值，然后用GetMem分配BufSize大小的动态内存作为内部缓冲区。
⑵ Destroy方法的实现
Destroy方法是TFiler对象的析构函数，它的作用就是释放动态内存。
destructor TFiler.Destroy;
begin
if FBuffer <> nil then FreeMem(FBuffer, FBufSize);
end;
20.2.2 TWriter对象
TWriter 对象是可实例化的，往流中写数据的Filer对象。TWriter对象直接从TFiler继承而来，除了覆盖从TFiler继承的方法外，还增加了大量的关于写各种数据类型(如Integer、String和Component等)的方法。TWriter对象和TReader 对象配合使用将使对象读写发挥巨大作用。
20.2.2.1 TWriter对象的属性和方法
1. Position属性
声明：property Position: Longint;
TWriter对象的Position属性表示相关联的流中的当前要写的位置，TReader 对象也有这个属性，但与TReader对象不同的是TWriter对象的Position的值比流的Position值小，这一点一看属性实现就清楚了。
2. RootAncesstor属性
声明：property RootAncestor: TComponent;
RootAncestor属性表示的是Root属性所指的部件的祖先。如果Root 是继承的窗体，Writer对象将窗体拥有部件与祖先窗体中的相应部件依次比较，然后只写入那些与祖先中的不同的部件。
3. Write方法
声明：procedure Write(const Buf; Count: Longint);
Write方法从Buf中往与Writer相关联的流中写入Count个字节。
4. WriteListBegin方法
声明：procedure WriteListBegin;
WriteListBegin方法往Write对象的流中写入项目列表开始标志，该标志意味着后面存储有一连串的项目。Reader对象，在读这一连串项目时先调用ReadListBegin方法读取该标志位，然后用EndOfList判断是否列表结束，并用循环语句读取项目。在调用WriteListBegin方法的后面必须调用WriteListEnd方法写列表结束标志，相应的在Reader对象中有ReadListEnd方法读取该结束标志。
5. WriteListEnd方法
声明：procedure WriteListEnd;
WriteListEnd方法在流中，写入项目列表结束标志，它是与WriteListBegin相匹配的方法。
6. WriteBoolean方法
声明：procedure WriteBoolean(Value: Boolean);
WriteBoolean方法将Value传入的布尔值写入流中。
7. WriteChar方法
声明：procedure WriteChar(Value: char);
WriteChar方法将Value中的字符写入流中。
8. WriteFloat方法
声明：procedure WriteFloat(Value: Extended);
WriteFloat方法将Value传入的浮点数写入流中。
9. WriteInteger方法
声明：procedure WriteInteger(Value: Longint);
WriteInteger方法将Value中的整数写入流中。
10. WriteString方法
声明：procedure WriteString(const Value: string);
WriteString方法将Value中的字符串写入流中。
11. WriteIdent方法
声明：procedure WriteIdent(const Ident: string);
WriteIdent方法将Ident传入的标识符写入流中。
12. WriteSignature方法
声明：procedure WriteSignature;
WriteSignature方法将Delphi Filer对象标签写入流中。WriteRootComponent方法在将部件写入流之前先调用WriteSignature方法写入Filer标签。Reader对象在读部件之前调用ReadSignature方法读取该标签以指导读操作。
13. WritComponent方法
声明：procedure WriteComponent(Component: TComponent);
WriteComponent方法调用参数Component的WriteState方法将部件写入流中。在调用WriteState之前，WriteComponent还将Component的ComponetnState属性置为csWriting。当WriteState返回时再清除csWriting.
14. WriteRootComponent方法
声明：procedure WriteRootComponent(Root: TComponent);
WriteRootComponent方法将Writer对象Root属性设为参数Root带的值，然后调用WriteSignature方法往流中写入Filer对象标签，最后调用WriteComponent方法在流中存储Root部件。
20.2.2.2 TWriter对象的实现
TWriter对象提供了许多往流中写各种类型数据的方法，这对于程序员来说是很重要的功能。TWrite对象往流中写数据是依据不同的数据采取不同的格式的。 因此要掌握TWriter对象的实现和应用方法，必须了解Writer对象存储数据的格式。
首先要说明的是，每个Filer对象的流中都包含有Filer对象标签。该标签占四个字节其值为“TPF0”。Filer对象为WriteSignature和ReadSignature方法存取该标签。该标签主要用于Reader对象读数据(部件等)时，指导读操作。
其次，Writer对象在存储数据前都要留一个字节的标志位，以指出后面存放的是什么类型的数据。该字节为TValueType类型的值。TValueType是枚举类型，占一个字节空间，其定义如下：
TValueType = (VaNull, VaList, VaInt8, VaInt16, VaInt32, VaEntended, VaString, VaIdent,
VaFalse, VaTrue, VaBinary, VaSet, VaLString, VaNil, VaCollection);
因此，对Writer对象的每一个写数据方法，在实现上，都要先写标志位再写相应的数据;而Reader对象的每一个读数据方法都要先读标志位进行判断，如果符合就读数据，否则产生一个读数据无效的异常事件。VaList标志有着特殊的用途，它是用来标识后面将有一连串类型相同的项目，而标识连续项目结束的标志是VaNull。因此，在Writer对象写连续若干个相同项目时，先用WriteListBegin写入VaList标志，写完数据项目后，再写出VaNull标志；而读这些数据时，以ReadListBegin开始，ReadListEnd结束，中间用EndofList函数判断是否有VaNull标志。
下面就介绍它们的实现。
1. TWriter对象属性的实现
TWriter对象直接从TFiler对象继承，它只增加了Position和RootAncestor属性。
RootAncestor属性在private部分有数据域FRootAncestor存入其值。在属性定义的读与控制上都是直接读取该值。
Position属性的定义中包含了两个读写控制方法：GetPosition和SetPosition：
TWriter = class(TFiler)
private
FRootAncestor: TComponent;
…
function GetPosition: Longint;
procedure SetPosition(Value: Longint);
public
…
property Position: Longint read GetPosition write SetPosition;
property RootAncestor: TComponent read FRootAncestor write FRootAncestor;
end;
GetPosition和SetPosition方法实现如下：
function TWriter.GetPosition: Longint;
begin
Result := FStream.Position + FBufPos;
end;
procedure TWriter.SetPosition(Value: Longint);
var
StreamPosition: Longint;
begin
StreamPosition := FStream.Position;
{ 只清除越界的缓冲区 }
if (Value < StreamPosition) or (Value > StreamPosition + FBufPos) then
begin
WriteBuffer;
FStream.Position := Value;
end
else FBufPos := Value - StreamPosition;
end;
WriteBuffer是TWriter对象定义的私有方法，它的作用是将Writer 对象内部缓冲区中的有效数据写入流中，并将FBufPos置为0。Writer对象的FlushBuffer对象就是用WriteBuffer方法刷新缓冲区。
在SetPosition方法中，如果Value值超出了边界(FStream.Position，FStream.Position + FBufPos)，就将缓冲区中的内容写入流，重新设置缓冲区在流中的相对位置；否则，就只是移动FBufPos指针。
2. TWriter方法的实现
⑴ WriteListBegin和WriteListEnd的实现
这两个方法都是用于写连续若干个相同类型的值。WriteListBegin写入VaList标志，WriteListEnd写入VaNull标志。
procedure TWriter.WriteListBegin;
begin
WriteValue(vaList);
end;
procedure TWriter.WriteListEnd;
begin
WriteValue(vaNull);
end;
这两个方法都调用TWriter对象的WriteValue方法，该方法主要用于写入TValueType类型的值。
procedure TWriter.WriteValue(Value: TValueType);
begin
Write(Value, SizeOf(Value));
end;
⑵ 简单数据类型的写入
简单数据类型指的是整型、字符型、字符串型、浮点型、布尔型等。TWriter对象都定义了相应的写入方法。
WriteInteger方法用于写入整型数据。
procedure TWriter.WriteInteger(Value: Longint);
begin
if (Value >= -128) and (Value <= 127) then
begin
WriteValue(vaInt8);
Write(Value, SizeOf(Shortint));
end else
if (Value >= -32768) and (Value <= 32767) then
begin
WriteValue(vaInt16);
Write(Value, SizeOf(Smallint));
end else
begin
WriteValue(vaInt32);
Write(Value, SizeOf(Longint));
end;
end;
WriteInteger方法将整型数据分为8位、16位和32位三种，并分别用vaInt8、vaInt16和VaInt32。
WriteBoolean用于写入布尔型数据：
procedure TWriter.WriteBoolean(Value: Boolean);
begin
if Value then
WriteValue(vaTrue) else
WriteValue(vaFalse);
end;
与其它数据类型不同的是布尔型数据只使用了标志位是存储布尔值，在标志位后没有数据。
WriteFloat方法用于写入浮点型数据。
procedure TWriter.WriteFloat(Value: Extended);
begin
WriteValue(vaExtended);
Write(Value, SizeOf(Extended));
end;
字符串“True”、“False”和“nil”作为标识符传入是由于Delphi的特殊需要。如果是“True”、“False”和“nil”则写入VaTrue、VaFalse和VaNil，否则写入VaIdent标志，接着以字符串形式写入标识符。
WriteString方法用于写入字符串
procedure TWriter.WriteString(const Value: string);
var
L: Integer;
begin
L := Length(Value);
if L <= 255 then
begin
WriteValue(vaString);
Write(L, SizeOf(Byte));
end else
begin
WriteValue(vaLString);
Write(L, SizeOf(Integer));
end;
Write(Pointer(Value)^, L);
end;
Delphi的字符串类型有两种。一种长度小于256个字节，另一种长度小于65536 个字节。WriteString方法区分这两类情况存储字符串，一种设置VaStirng标志，另一种设置VaLString。然后存储字符串的长度值，最后存储字符串数据。
WriteChar方法用于写入字符。
procedure TWriter.WriteChar(Value: Char);
begin
WriteString(Value);
end;
字符类型的读写是用读写字符串的方法，在读的时候，判断字节数为1时，则为字符型。
⑶ 部件的写入
TWriter对象中与写入部件有关的方法有WriteSignature、WritePrefix、WriteComponent、WriteDescendant和WriteRootComponent。
WriteSignature方法用于往流中写入Filer对象标签。
procedure TWriter.WriteSignature;
begin
Write(FilerSignature, SizeOf(FilerSignature));
end;
FilerStgnature是字符串常量，其值为“TPF0”，代表对象标签。
WritePrefix方法用于在写入部件前写入ffInherited和ffChildPos标志，这些标志表示部件的继承特征和创建序值特征。
procedure TWriter.WritePrefix(Flags: TFilerFlags; AChildPos: Integer);
var
Prefix: Byte;
begin
if Flags <> [] then
begin
Prefix := $F0 or Byte(Flags);
Write(Prefix, SizeOf(Prefix));
if ffChildPos in Flags then WriteInteger(AChildPos);
end;
end;
如果ffChildPos置位，则存入部件在Owner中的创建序值。更详细的信息请参阅TReader的ReadPrefix方法。
WriteComponent方法往流中写入部件。
procedure TWriter.WriteComponent(Component: TComponent);
function FindAncestor(const Name: string): TComponent;
begin
…
end;
begin
Include(Component.FComponentState, csWriting);
if Assigned(FAncestorList) then
Ancestor := FindAncestor(Component.Name);
Component.WriteState(Self);
Exclude(Component.FComponentState, csWriting);
end;
方法中用Component的WritState方法写入部件的属性。在写入之前将Component.FComponentState置为csWriting写入完后再将csWriting复位。
WriteDescendant是根据祖先AAncestor的情况写入部件Root。
procedure TWriter.WriteDescendent(Root: TComponent; AAncestor: TComponent);
begin
FRootAncestor := AAncestor;
FAncestor := AAncestor;
FRoot := Root;
WriteSignature;
WriteComponent(Root);
end;
方法先调用WriteSignature方法写入Filer对象标签。然后调用WriteComponent将部件Root写入流。
WriteRootComponent方法则是调用WriteDescendant方法写入部件，只是将后者的Ancestor参数以nil值传入。
procedure TWriter.WriteRootComponent(Root: TComponent);
begin
WriteDescendent(Root, nil);
end;
20.2.3 TReader对象
TReader对象是可实例化的用于从相联系的流中读取数据的Filer对象。TReader对象从TFiler继承下来，除了从TFiler继承的属性和方法外，TReader声明了不少属性、方法和事件。
Owner和Parent属性用于表示从Reader对象的流中读取的部件的拥有者和双亲结点。OnError，OnFindMethod和OnSetName事件使应用程序在运行中读数据时能定制响应方式。除了覆盖了一些从TFiler对象中继承的方法外，TReader对象还定义大量的读不同类型的数据和触发事件的方法。
20.2.3.1 TReader对象的属性和方法
1. Owner属性
声明：property Owner: TComponent;
Reader对象的Owner属性存储了将用来给从Reader的流中读出的部件的Owner属性赋值的部件。
2. Parent属性
声明：property Parent: TComponent;
Parent属性存储将用来给从Reader的流中读出所有控制的Parent属性赋值的部件。
3. Position属性
声明：propertion: Longint;
Reader对象的Position属性表示相联的流中读的当前位置。Position的值还应包括读缓冲区的大小。对于Reader 对象，Position的值大于流的Position 的值。如果将Position的值设得超过当前缓冲区，将引起调用FlushBuffer。
4. BeginReferences方法
声明：procedure BeginReferences;
BeginReferences方法启动一连串关于读部件的命令，这些部件包含相互间的交叉引用。在使用上通常和FixupReferences和EndReferences一起放在Try…finally程序块中。
在调用了BeginReferences后，Reader对象创建读取所有对象和名字的列表。所有的独立对象被读出后，调用FixupReferences方法将名字的相互从流中转移到对象实例中。最后调用EndReferences方法释放列表。
处理部件相互引用的程序块形式如下：
BeginReferences; { 创建临时列表 }
try
{ 读出所有部件并将它们的名字放在一临时列表中 }
…
FixupReferences; { 分 解 }
finally
EndReferences; { 释放临时列表 }
end;
5. FixUpReferences方法
声明：procedure FixupReferences;
FixupReferences方法分解从流中读出的存在各种相互依赖部件的引用关系。FixupReferences总在try…finally块中并配合BeginReferences和EndReferences一起使用。
6. EndReferences方法
声明：procedure EndReferences;
EndReferences方法终止处理相互引用的块操作，释放对象列表。它总配合BeginReferences和FixupReferences一起使用。
7. ReadListBegin方法
声明：procedure ReadListBegin;
ReadListBegin方法从Reader对象相联的流中读取列表开始标志。如果流中紧接着要读取的项目不是一个由WritelistBegin方法写入的列表起始标志，ReadListBegin将引起一个读异常事件。
通常在调用ReadlistBegin方法之后，紧跟着一个读项目的循环，循环以EndfList方法返回True 终止条件。这时，预示流中的下一个项目是列表结束标志，需要调用ReadListEnd方法。
8. ReadListEnd方法
声明：procedure ReadListEnd;
ReadListEnd 方法从流中读取列表结束标志。如果所读的项目不是一个列表结束标志，ReadListEnd方法引发一个EReadError异常事件。
9. EndOfList方法
声明：function EndOfList: Boolean;
如果Reader对象读到项目列表结果标志，EndOfList方法返回True。
TStrings对象在从Reader对象读取项目列表时使用了ReadListBegin和ReadListEnd方法。下面的ReadData是TStrings的方法，用于在DefineProperties方面中读string数据。
procedure TStrings.ReadData(Reader: TReader);
begin
Reader.ReadListBegin; { 读列表开始标志 }
Clear; { 清除已有的字符串 }
while not Reader.EndOfList do { 只要还有数据 … }
Add(Reader.ReadString); { …读一个字符串并将其加在列表中 }
Reader.ReadListEnd; { 越过列表结束标志 }
end;
10. ReadSignature方法
声明：procedure ReadSignature;
ReadSignature方法从流中读取部件之前首先调用ReadSignature方法。在载入对象之前检测标签。Reader对象就能防止疏忽大意，导致读取无效或过时的数据。Filer标签是四个字符，对于Delphi 2.0，该标签是“TPF0”。
11. ReadPrefix方法
声明：procedure ReadPrefix(var Plags: TFilerFlags; var AChild, Pos: Integer);
ReadPrefix方法的功能与ReadSignature的很相象，只不过它是读取流中部件前面的标志(PreFix)。当一个Write对象将部件写入流中时，它在部件前面预写了两个值，第一个值是指明部件是否是从祖先窗体中继承的窗体和它在窗体中的位置是否重要的标志;第二个值指明它在祖先窗体创建次序。ReadComponent方法自动调用ReadPrefix。但如果需要独立读取部件的预读标志，也可直接调用该方向。
12. OnFindMethod事件
声明：property OnFindMethod: TFindMethodEvent;
OnFindMethod事件，发生在Reader对象读取对象的方法指针时，属性为方法指针的通常都是事件。
响应OnFindMethod事件的理由，通常是处理过程找不到方法的情况。在FindMethod方法没有找到由Name指定的方法的情况下，如果它将OnFindMethod方法的Error 参数设为True，将引起ReadError异常事件；反之，将Error参数置为False，将防止FindMethod方法引发异常事件。
13. Error方法
声明：function Error(const Message: String): Boolean; virtual;
Error方法定义在Reader对象的protected部分，它是用于Reader对象的OnError事件。其返回值决定是否继续错误处理过程。如果返回值为True，则表示用程序应当继续错误处理；如果返回值为False，则表示错误情况被忽略。
如果读部件或属性出错。Reader对象调用Error方法。缺省情况下，Error将返回值设为False，然后调用OnError事件处理过程。
TReader对象总是在try…except程序块的except部分，并提供用户忽略错误的机会。Error的使用方法如下：
try
… { 读部件 }
except
on E: Exception do
begin
…{ 执行一些清除操作 }
if Error(E.Message) then raise;
end;
end;
14. OnError事件
声明：property OnError: TReaderError;
当Reader对象读取数据出错时将引发OnError事件。通过处理OnError事件，可以有选择地处理或忽略错误。
传给OnError事件处理过程的最后一个参数是名为Handled的var参数。在缺省情况下，Error方法将Handled置为True。这将阻止错误更进一步处理。如果事件处理过程仍旧将Handled置为False，Reader对象将引发一个EReadError异常事件。
15. SetName方法
声明：procedure SetName(Component: TComponent; var Name: String virtual);
SetName方法允许Reader对象在将从流中读取的部件的Name值赋给部件的Name属性前修改Name值。ReadComponent方法在读取部件的属性值和其它数据前先读部件的类型和名字在读完名字后，ReadComponent将所读的名字作为Name参数传给SetName，Name 是个var参数，因此SetName能在返回前修改字符串值。SetName还调用了OnSetName事件处理过程，将名字字符串作为var参数传入事件处理过程中，因此，事件处理过程也可修改字符串的值。
16. OnSetName事件
声明：property OnSetName: TSetNameEvent;
OnSetName事件发生在Read对象设置部件的Name属性前，OnSetName事件处理过程的var参数Name参数是一个var参数，因此，事件处理过程再将Name赋给部件前，可以修改Name的值。这对于想过滤窗体中部件的名字是很有帮助的。
下面的OnSetName事件处理过程，命名了名字中包含“Button”的部件，并用“PushButton”替代。
procedure TForm1.ReaderSetName(Reader: TReader; Component: TComponent;
var Name: string);
var
ButtonPos: Integer;
begin
ButtonPos := Pos('Button', Name);
if ButtonPos <> 0 then
Name := Copy(Name, 1, ButtonPos - 1) + 'PushButton' +
Copy(Name, ButtonPos + 6, Length(Name));
end;
17. ReadValue方法
声明：function ReadValue: TValueType;
ReadValue方法读取流中紧着的项目的类型，函数返回后，流的指针移到值类型指示符之后。
TValueType是枚举类型。存储在Filer对象的流中的每个项目之前都有一个字节标识该项目的类型，在读每个项目之前都要读取该字节，以指导调用哪个方法来闱取项目。该字节的值就TValuetype定义的值类型之一。
18. NextValue方法
声明：function Nextvalue: TValuetype;
Nextvalue方法的作用也是返回Reader对象流中紧接着的项目的类型，它与ReadValue的区别在于并不移动指针位置。
19. ReadBoolean方法
声明：function ReadBoolean: Boolean;
ReadBoolean方法从Reader对象的流中读取一个布尔值，并相应地移动流位置指针。
20、ReadChar方法
声明：function ReadChar: char;
ReadChar方法从Reader对象的流中读取一个字符。
21. ReadFloat方法
声明：function ReadFloat: Extended;
ReadFloat方法从流中读取浮点数。
20. ReadIdent方法
声明：function ReadIdent: string;
ReadIdent方法从流中读取标识符。
23. ReadInteger方法
声明：function ReadInteger: Longin
ReadInteger方法从流中读取整型数字。
24.ReadString方法
声明：function Read String: string;
ReadString方法从Reader对象的流中读取一个字符串，并返回字符串中的内容。该字符串是由Writer对象的WriteString方法写入。
20.2.3.2 TReader对象的实现
Filer对象的作用主要是Delphi用来在DFM文件中读写各种类型的数据（包括部件对象）。这些数据的一个本质特征是变长，而且Filer对象将读写数据操作抽象化，包装成对象提供了大量的读写方法，方便了程序的调用。因此在应用程序中可以广泛使Filer对象，充分利用Delphi的面向对象技术。而且Filer对象与Stream对象捆绑在一起，一方面可以在各种存储媒介中存取任意格式的数据；另一方面，由于充分利用面向对象的动态联编，各种读写方法的使用方法是一致的，因此，方法调用很简单。下面我们着重介绍Reader 对象中与读写数据操作有关的属性和方法的实现。
1. TReader属性的实现
在TReader对象的属性实现中我们重点介绍Position的实现。
Position属性的定义了使用了读写控制，它们分别是GetPosition和SetPosition方法。
TReader = class(TFiler)
private
…
function GetPosition: Longint;
procedure SetPosition(Value: Longint);
public
…
property Position: Longint read GetPosition write SetPosition;
end;
Postition的读写控制方法如下：
function TReader.GetPosition: Longint;
begin
Result := FStream.Position + FBufPos;
end;
procedure TReader.SetPosition(Value: Longint);
begin
FStream.Position := Value;
FBufPos := 0;
FBufEnd := 0;
end;
在TReader的父对象TFiler对象中介绍过FBufPos和FBufEnd变量。Filer对象内部分配了一个BufSize大小的缓冲区FBufPos就是指在缓冲区中的相对位置，FBufEnd是指在缓冲区中数据结束处的位置(缓冲区中的数据不一定会充满整个缓冲区)。
在GetPosition方法中可以看到Reader对象的Position值和Stream对象的Position值是不同的。Reader对象多了一个FButPos的编移量。
2. Defineproperty和DefineBinaryproperty方法的实现
这两个方法是虚方法，在TFiler中是抽象方法，在TReader和TWriter对象中才有具体的实现。
它们在TReader中的实现如下：
procedure TReader.DefineProperty(const Name: string; ReadData: TReaderProc;
WriteData: TWriterProc; HasData: Boolean);
begin
if CompareText(Name, FPropName) = 0 then
begin
ReadData(Self);
FPropName := '';
end;
end;
procedure TReader.DefineBinaryProperty(const Name: string;
ReadData, WriteData: TStreamProc; HasData: Boolean);
var
Stream: TMemoryStream;
Count: Longint;
begin
if CompareText(Name, FPropName) = 0 then
begin
if ReadValue <> vaBinary then
begin
Dec(FBufPos);
SkipValue;
FCanHandleExcepts := True;
PropValueError;
end;
Stream := TMemoryStream.Create;
try
Read(Count, SizeOf(Count));
Stream.SetSize(Count);
Read(Stream.Memory^, Count);
FCanHandleExcepts := True;
ReadData(Stream);
finally
Stream.Free;
end;
FPropName := '';
end;
end;
在两个方法都将Name参数值与当前的属性名比较，如果相同则进行读操作。在DefineBinaryproperty中，创建了一个内存流。先将数据读到内存流中然后调用ReadData读取数据。
3. FlushBuffer的实现
FlushBuffer方法用于清除Reader对象的内部缓冲区中的内容，保持Reader对象和流在位置（Position）上的同步，其实现如下：
procedure TReader.FlushBuffer;
begin
FStream.Position := FStream.Position - (FBufEnd - FBufPos);
FBufPos := 0;
FBufEnd := 0;
end;
4. ReadListBegin、ReadListEnd和EndOfList方法
这三个方法都是用于从Reader对象的流中读取一连串的项目，并且这些项目都由WriteListBegin写入的标志标定开始和WriteListEnd写入标志，标定结束，在读循环中用EndOfList进行判断。它们是在Reader对象读取流中数据时经常用于的。它们的实现如下：
procedure TReader.ReadListBegin;
begin
CheckValue(vaList);
end;
procedure TReader.ReadListEnd;
begin
CheckValue(vaNull);
end;
function TReader.EndOfList: Boolean;
begin
Result := ReadValue = vaNull;
Dec(FBufPos);
end;
项目表开始标志是VaList，项目表结束标志是VaNull，VaList和VaNull都是枚举类型TValueType定义的常量。
它们实现中调用的CheckValue是TReader的私有方法，其实现如下：
procedure TReader.CheckValue(Value: TValueType);
begin
if ReadValue <> Value then
begin
Dec(FBufPos);
SkipValue;
PropValueError;
end;
end;
CheckValue方法的功能是检测紧接着要读的值是否是Value指定的类型。如果不是则跳过该项目并触发一个SInvalidPropertyValue错误。
EndOfList函数只是简单地判断下一字节是否是VaNull将判断结果返回，并将字节移回原来位置。
5. 简单数据类型读方法的实现
简单数据类型指的是布尔型、字符型、整型、字符串型、浮点型、集合类型和标识符。将它们放在一起介绍是因为它们的实现方法类似。
因为它们的实现都用到了ReadValue方法，因此先来介绍ReadValue方法的实现：
function TReader.ReadValue: TValueType;
begin
Read(Result, SizeOf(Result));
end;
该方法调用私有方法Read，从Reader对象流中读一个字节，并移动位置指针。
ReadValue方法专门从流中读取值的类型的，所有的数据读写方法中在读取数据前都要调用ReadValue方法判断是否是所要读的数据。如果是，则调用Read方法读取数据；否则触发一个异常事件，下面看Integer类型的读方法：
function TReader.ReadInteger: Longint;
var
S: Shortint;
I: Smallint;
begin
case ReadValue of
vaInt8:
begin
Read(S, SizeOf(Shortint));
Result := S;
end;
vaInt16:
begin
Read(I, SizeOf(I));
Result := I;
end;
vaInt32:
Read(Result, SizeOf(Result));
else
PropValueError;
end;
end;
因为Delphi 2.0中，整型可分8位、16位和32位，因此读取整型数据时分别作了判断。
布尔类型的数据是直接放在值类型标志上，如果类型为VaTrue，则值为True；如果类型为VaFalse，则值为False。
function TReader.ReadBoolean: Boolean;
begin
Result := ReadValue = vaTrue;
end;
ReadString方法也利用ReadValue方法判断是字符串还是长字符串。
function TReader.ReadString: string;
var
L: Integer;
begin
L := 0;
case ReadValue of
vaString:
Read(L, SizeOf(Byte));
vaLString:
Read(L, SizeOf(Integer));
else
PropValueError;
end;
SetString(Result, PChar(nil), L);
Read(Pointer(Result)^, L);
end;
如果VaString类型紧接着一个字节存有字符串的长度；如果是VaLString类，则紧接着两个字节存放字符串长度，然后根据字符串长度用SetString过程给分配空间，用Read方法读出数据。
ReadFloat方法允许将整型值转换为浮点型。
function TReader.ReadFloat: Extended;
begin
if ReadValue = vaExtended then Read(Result, SizeOf(Result)) else
begin
Dec(FBufPos);
Result := ReadInteger;
end;
end;
字符类型数据设有直接的标志，它是根据VaString后面放一个序值为1的字节来判断的。
function TReader.ReadChar: Char;
begin
CheckValue(vaString);
Read(Result, 1);
if Ord(Result) <> 1 then
begin
Dec(FBufPos);
ReadStr;
PropValueError;
end;
Read(Result, 1);
end;
出于读取DFM文件需要，Filer对象支持读取标识符。
function TReader.ReadIdent: string;
var
L: Byte;
begin
case ReadValue of
vaIdent:
begin
Read(L, SizeOf(Byte));
SetString(Result, PChar(nil), L);
Read(Result[1], L);
end;
vaFalse:
Result := 'False';
vaTrue:
Result := 'True';
vaNil:
Result := 'nil';
else
PropValueError;
end;
end;
一般说来，各种复杂的数据结构都是由这些简单数据组成;定义了这些方法等于给读各种类型的数据提供了元操作，使用很方便。例如，读取字符串类型的数据时，如果采用传流方法还要判断字符串的长度，使用ReadString方法就不同了。但应该特别注意的是这些类型数据的存储格式是由Delphi设计的与简单数据类型有明显的不同。因此，存入数据时应当使用Writer对象相应的方法，而且在读数据前要用NextValue方法进行判断，否则会触发异常事件。
6. 读取部件的方法的实现
Reader对象中用于读取部件的方法有ReadSignature、ReadPrefix、ReadComponent、ReadRootComponent和ReadComponents。
ReadSignature方法主要用于读取Delphi Filer对象标签一般在读取部件前，都要用调用ReadSignature方法以指导部件读写过程。
procedure TReader.ReadSignature;
var
Signature: Longint;
begin
Read(Signature, SizeOf(Signature));
if Signature <> Longint(FilerSignature) then ReadError(SInvalidImage);
end;
FilerSignature就是Filer对象标签其值为“TPF0” ，如果读的不是“TPF0” ，则会触发SInValidImage异常事件。
ReadPrefix方法是用于读取流中部件前的标志位，该标志表示该部件是否处于从祖先窗体中继承的窗体中和它在窗体中的位置是否很重要。
procedure TReader.ReadPrefix(var Flags: TFilerFlags; var AChildPos: Integer);
var
Prefix: Byte;
begin
Flags := [];
if Byte(NextValue) and $F0 = $F0 then
begin
Prefix := Byte(ReadValue);
Byte(Flags) := Prefix and $0F;
if ffChildPos in Flags then AChildPos := ReadInteger;
end;
end;
TFilerFlags的定义是这样的：
TFilerFlag = (ffInherited, ffChildPos);
TFilerFlags = Set of TFilerFlag;
充当标志的字节的高四位是$F，低四位是集合的值，也是标志位的真正含义。如果ffChildPos置位，则紧接着的整型数字中放着部件在窗体中的位置序值。
ReadComponent方法用于从Reader对象的流中读取部件。Component 参数指定了要从流中读取的对象。函数返回所读的部件。
function TReader.ReadComponent(Component: TComponent): TComponent;
var
CompClass, CompName: string;
Flags: TFilerFlags;
Position: Integer;
…
begin
ReadPrefix(Flags, Position);
CompClass := ReadStr;
CompName := ReadStr;
Result := Component;
if Result = nil then
if ffInherited in Flags then
FindExistingComponent else
CreateComponent;
if Result <> nil then
try
Include(Result.FComponentState, csLoading);
if not (ffInherited in Flags) then SetCompName;
if Result = nil then Exit;
Include(Result.FComponentState, csReading);
Result.ReadState(Self);
Exclude(Result.FComponentState, csReading);
if ffChildPos in Flags then Parent.SetChildOrder(Result, Position);
FLoaded.Add(Result);
except
if ComponentCreated then Result.Free;
raise;
end;
end;
ReadCompontent方法首先调用ReadPrefix方法，读出部件标志位和它的创建次序值(Create Order)。然后用ReadStr方法分别读出部件类名和部件名。如果Component参数为nil，则执行两个任务：
● 如果ffInberited 置位则从Root 找已有部件，否则，就从系统的Class表中找到该部件类型的定义并创建
● 如果结果不为空，将用部件的ReadState方法读入各种属性值，并设置部件的Parent 属性，并恢复它在Parent部件的创建次序。
ReadComponent方法主要是调用ReadComponent方法从Reader对象的流中读取一连串相关联的部件，并分解相互引用关系。
procedure TReader.ReadComponents(AOwner, AParent: TComponent;
Proc: TReadComponentsProc);
var
Component: TComponent;
begin
Root := AOwner;
Owner := AOwner;
Parent := AParent;
BeginReferences;
try
while not EndOfList do
begin
ReadSignature;
Component := ReadComponent(nil);
Proc(Component);
end;
FixupReferences;
finally
EndReferences;
end;
end;
ReadComponents首先用AOwner和AParent参数给Root,Owner和Parent赋值，用于重建各部件的相互引用。然后用一个While循环读取部件并用由Proc传入的方法进行处理。在重建引用关系时，用了BeginReferences、FixUpReferences和EndReferences嵌套模式。
ReadRootComponent方法从Reader对象的流中将部件及其拥有的部件全部读出。如果Component参数为nil，则创建一个相同类型的部件，最后返回该部件：
function TReader.ReadRootComponent(Root: TComponent): TComponent;
function FindUniqueName(const Name: string): string;
begin
…
end;
var
I: Integer;
Flags: TFilerFlags;
begin
ReadSignature;
Result := nil;
try
ReadPrefix(Flags, I);
if Root = nil then
begin
Result := TComponentClass(FindClass(ReadStr)).Create(nil);
Result.Name := ReadStr;
end else
begin
Result := Root;
ReadStr; { Ignore class name }
if csDesigning in Result.ComponentState then
ReadStr else
Result.Name := FindUniqueName(ReadStr);
end;
FRoot := Result;
if GlobalLoaded <> nil then
FLoaded := GlobalLoaded else
FLoaded := TList.Create;
try
FLoaded.Add(FRoot);
FOwner := FRoot;
Include(FRoot.FComponentState, csLoading);
Include(FRoot.FComponentState, csReading);
FRoot.ReadState(Self);
Exclude(FRoot.FComponentState, csReading);
if GlobalLoaded = nil then
for I := 0 to FLoaded.Count - 1 do TComponent(FLoaded[I]).Loaded;
finally
if GlobalLoaded = nil then FLoaded.Free;
FLoaded := nil;
end;
GlobalFixupReferences;
except
RemoveFixupReferences(Root, '');
if Root = nil then Result.Free;
raise;
end;
end;
ReadRootComponent首先调用ReadSignature读取Filer对象标签。然后在try…except循环中执行读取任务。如果Root参数为nil，则用ReadStr读出的类名创建新部件，并以流中读出部件的Name属性；否则，忽略类名，并判断Name属性的唯一性。最后用Root的ReadState方法读取属性和其拥有的拥有并处理引用关系。
7. SetName方法和OnSetName事件
因为在OnSetName事件中，Name参数是var型的，所以可以用OnSetName事件处理过程修改所读部件的名字。而OnSetName事件处理过程是在SetName方法中实现的。
procedure TReader.SetName(Component: TComponent; var Name: string);
begin
if Assigned(FOnSetName) then FOnSetName(Self, Component, Name);
Component.Name := Name;
end;
SetName方法和OnSetName事件在动态DFM文件的编程中有很重要的作用。
8. TReader的错误处理
TReader的错误处理是由Error方法和OnError事件的配合使用完成的。OnError 事件处理过程的Handled参数是var型的布尔变量，通过将Handled设为True或False可影响TReader 的错误处理。OnError事件处理过程是在Error方法中调用的。
function TReader.Error(const Message: string): Boolean;
begin
Result := False;
if Assigned(FOnError) then FOnError(Self, Message, Result);
end;
9. FindMethod和OnFindMethod事件
有时，在程序运行期间，给部件的方法指针(主要是事件处理过程)动态赋值是很有用的，这样就能动态地改变部件响应事件的方式。在流中读取部件捍做到一点就要利用OnFindMehtod事件。OnFIndMethod事件是在FindMethod方法中被调用的。
function TReader.FindMethod(Root: TComponent;
const MethodName: string): Pointer;
var
Error: Boolean;
begin
Result := Root.MethodAddress(MethodName);
Error := Result = nil;
if Assigned(FOnFindMethod) then FOnFindMethod(Self, MethodName, Result,
Error);
if Error then PropValueError;
end;
OnFindMethod 方法除了可以给部件的MethodName所指定的方法指针动态赋值外，还可修改Error参数来决定是否处理Missing Method错误。方法中调用的MehtodAddress 方法定义在TObject中，它是个很有用的方法，它可以得到对象中定义的public方法的地址。FindMethod方法和OnFindMethod事件在动态DFM的编程中有很重要的作用。
20.3 Delphi对象式数据管理应用实例
Delphi 2.0无论是其可视化设计工具，还是可视化部件类库(VCL)，都处处渗透了对象存储技术，本节将从Delphi可视化设计内部机制、VCL中的数据存储、BLOB数据操作和动态生成部件的存储几方面介绍对象存储功能的实例应用。
20.3.1 Delphi 动态DFM文件及部件的存取在超媒体系统中的应用
Delphi的可视化设计工具是同其部件类库紧密结合在一起的。
每个部件只有通过一段注册程序并通过Delphi的Install Component功能，才能出现在Component Palette上；部件的属性才有可能出现在Object Inspector窗口中；部件的属性编辑器才能被Delphi环境使用。因为这种浑然天成的关系，DFM文件存取必然得到VCL在程序上的支持。
DFM文件的部件存取是Delphi可视化设计环境中文件存取的中心问题。因为Delphi可视化设计的核心是窗体的设计。每个窗体对应一个库单元，是应用程序的模块，窗体在磁盘上的存储就是DFM文件。
DFM文件结构我们前面介绍过了。它实际上是存储窗体及其拥有的所有部件的属性。这种拥有关系是递归的。问题在于如何将这些属性数据与程序中的变量(属性)代码联系起来。
在Delphi中处理这种联系的过程分为两种情况：设计时和运行时。
在设计时，建立联系表现为读取DFM 文件，建立DFM文件中的部件及其属性与可视化设计工具(Object Inspector、窗体设计窗口和代码编辑器)的联系，也就是说让这些部件及其属性能出现在这些窗口中，并与代码中的属性定义联系起来；分解联系表现为存储DFM文件，将窗体窗口中的部件及其属性写入DFM文件。
在运行时，主要是建立联系的过程，即读取DFM文件。这时，DFM文件不是作为独立的磁盘文件，而是以应用程序资源中的RCDATA类型的二进制数据存在。建立联系的过程表现为将资源中的部件及其属性与应用程序中的对象及其数据域联系起来。其过程为：根据DFM中的部件类名创建对象，再将用DFM中的部件属性值给程序中的部件属性赋值。当然要完成这一过程，还必须在代码中有相应的窗体定义，因为方法等代码是不存入部件的。
VCL对读取DFM文件在代码上的支持是通过Stream对象和Filer对象达到的。在20. 1和20.1节中，我们可以看到Stream对象和Filer对象中有大量的用于存取部件及其属性的方法，尤其在TReader对象中，还有关于错误处理和动态的方法赋值的方法。下面我们就通过程序实例介绍存取DFM文件方法、步骤和注意事项。
20.3.1.1写DFM文件的过程：WriteComponentResFie
该过程带有两个参数FileName和Instance。FileName参数指定要写入的DFM文件名，Instance参数是TComponent类型的，它指定要写入的部件名，一般是TForm对象的子类。该过程将Instance部件和其拥有的所有部件写入DFM文件。
这个过程的意义在于，可以在程序运行过程中产生Delphi的窗体部件和在窗体中插入部件，并由该函数将窗体写入DFM文件，支持了动态DFM文件的重用性。
该过程的程序是这样的：
procedure WriteComponentResFile(const FileName: string; Instance: TComponent);
var
Stream: TStream;
begin
Stream := TFileStream.Create(FileName, fmCreate);
try
Stream.WriteComponentRes(Instance.ClassName, Instance);
finally
Stream.Free;
end;
end;
函数中，用FileStream创建文件，用Stream对象的WriteComponetRes方法将Instance写入流中。
20.3.1.2 读DFM文件的函数：ReadComponentResFile
ReadComponentResFile函数带有两个参数FileName和Instance。FileName参数指定要读DFM文件名，Instance参数指定从DFM文件中要读的部件。该函数从DFM文件中将Instance和它拥有的所有部件，并返回该部件。
这个函数的意义在于，配合WriteComponentResFile过程的使用支持DFM文件的重用性。
该函数的程序是这样的：
function ReadComponentResFile(const FileName: string; Instance: TComponent):
TComponent;
var
Stream: TStream;
begin
Stream := TFileStream.Create(FileName, fmOpenRead);
try
Result := Stream.ReadComponentRes(Instance);
finally
Stream.Free;
end;
end;
程序中使用FileStream对象打开由FileName指定的DFM文件，然后用Stream对象的ReadComponentRes方法读出Instance，并将读的结果作为函数的返回值。
20.3.1.3 读取Delphi应用程序资源中的部件
函数InternalReadComponentRes可以读取Delphi应用程序资源中的部件。Delphi 的DFM文件在程序经过编译链接后被嵌入应用程序的资源中，而且格式发生了改变，即少了资源文件头。
在第一节中曾经介绍过TResourceStream对象，该对象是操作资源媒介上的数据的。函数InternalReadComponentRes用了TResourceStream。程序是这样的：
function InternalReadComponentRes(const ResName: string;
var Instance: TComponent): Boolean;
var
HRsrc: THandle;
begin { 避免“EResNotFound”异常事件的出现 }
HRsrc := FindResource(HInstance, PChar(ResName), RT_RCDATA);
Result := HRsrc <> 0;
if not Result then Exit;
FreeResource(HRsrc);
with TResourceStream.Create(HInstance, ResName, RT_RCDATA) do
try
Instance := ReadComponent(Instance);
finally
Free;
end;
Result := True;
end;
HInstance是一个Delphi VCL定义的全局变量，代表当前应用程序的句柄。函数用了资源访问API函数FindResource来测定是否存在ResName所描述资源。因为在TResourceStream的创建过程还有FindResource等操作，所以函数中调用了FreeResource。最后函数调用了Stream对象的ReadComponent方法读出部件。因为函数的Instance是var类型的参数，所以可以访问Instance，得到读出的部件。
20.3.1.4 DFM文件与标准文本文件(TXT文件)的相互转换
在Delphi可视化设计环境中，允许程序员在代码编辑器中以文本的方式浏览和修改DFM文件内容。当用File/Open命令直接打开DFM文件或者选择窗体设计窗口的弹出式菜单上的View as Text命令时，就会在编辑器中出现文本形式的信息。我们姑且将这种文本形式称之为窗体设计脚本。Delphi提供的这种脚本编辑功能是对Delphi可视化设计的一大补充。当然这个脚本编辑能力是有限制的，比方说不能在脚本任意地添加和删除部件，因为代码和DFM脚本是紧密相连的，任意添加和修改会导致不一致性。然而在动态生成的DFM文件中，就不存在这一限制，后面会介绍DFM动态生成技术的应用。
实际上，DFM文件内容是二进制数据，它的脚本是经过Delphi开发环境自动转化的，而且Delphi VCL中的Classes库单元中提供了在二进制流中的文件DFM和它的脚本之相互转化的过程。它们是ObjectBinaryToText和ObjectTextBinary、ObjectResourceToText和ObjectTextToResource。
ObjectBinaryToText过程将二进制流中存储的部件转化为基于文本的表现形式，这样就可以用文本处理函数进行处理，还可以用文本编辑器进行查找和替代操作，最后可以将文本再转化成二进制流中的部件。
ObjectBinaryToText过程的主程序是这样的：
procedure ObjectBinaryToText(Input, Output: TStream);
var
NestingLevel: Integer;
SaveSeparator: Char;
Reader: TReader;
Writer: TWriter;
procedure WriteIndent;
const
Blanks: array[0..1] of Char = ' ';
var
I: Integer;
begin
for I := 1 to NestingLevel do Writer.Write(Blanks, SizeOf(Blanks));
end;
procedure WriteStr(const S: string);
begin
Writer.Write(S[1], Length(S));
end;
procedure NewLine;
begin
WriteStr(#13#10);
WriteIndent;
end;
procedure ConvertHeader;
begin
…
end;
procedure ConvertBinary;
begin
…
end;
procedure ConvertValue;
begin
…
end;
procedure ConvertProperty;
begin
…
end;
procedure ConvertObject;
begin
…
end;
begin
NestingLevel := 0;
Reader := TReader.Create(Input, 4096);
SaveSeparator := DecimalSeparator;
DecimalSeparator := '.';
try
Writer := TWriter.Create(Output, 4096);
try
Reader.ReadSignature;
ConvertObject;
finally
Writer.Free;
end;
finally
DecimalSeparator := SaveSeparator;
Reader.Free;
end;
end;
过程中调用的ConvertObject过程是个递归过程，用于将DFM文件中的每一个部件转化为文本形式。因为由于部件的拥有关系，所以部件成嵌套结构，采用递归是最好的方式：
procedure ConvertObject;
begin
ConvertHeader;
Inc(NestingLevel);
while not Reader.EndOfList do ConvertProperty;
Reader.ReadListEnd;
while not Reader.EndOfList do ConvertObject;
Reader.ReadListEnd;
Dec(NestingLevel);
WriteIndent;
WriteStr('end'#13#10);
end;
NestStingLevel变量表示部件的嵌套层次。WriteIndent是写入每一行起始字符前的空格，ConvertHeader过程是处理部件的继承标志信息。转换成的头信息文本有两种形式。
Inherited TestForm1: TTestForm[2]
或者：
Object TestForm1: TTestForm
前者是ffInherited和ffChildPos置位，后面是都没置位。
ConvertProperty过程用于转化属性。
procedure ConvertProperty;
begin
WriteIndent;
WriteStr(Reader.ReadStr);
WriteStr(' = ');
ConvertValue;
WriteStr(#13#10);
end;
WriteIndent语句写入属性名前的空格，WriteStr(Reader.ReadStr)语句写入属性名ConvertValue过程根据属性的类型将属性值转化为字符串，然后写入流中。
ObjectTextToBinary过程执行的功能与ObjectBinaryToText相反，将TXT文件转换为二进制流中的部件，而且只要TXT文件内容的书写符合DFM脚本语法，ObjectTextToBinary可将任何程序生成的TXT文件转换为部件，这一功能也为DFM 文件的动态生成和编辑奠定了基础。ObjectTextToBinary过程的主程序如下：
procedure ObjectTextToBinary(Input, Output: TStream);
var
SaveSeparator: Char;
Parser: TParser;
Writer: TWriter;
…
begin
Parser := TParser.Create(Input);
SaveSeparator := DecimalSeparator;
DecimalSeparator := '.';
try
Writer := TWriter.Create(Output, 4096);
try
Writer.WriteSignature;
ConvertObject;
finally
Writer.Free;
end;
finally
DecimalSeparator := SaveSeparator;
Parser.Free;
end;
end;
在程序流程和结构上与ObjectBinaryToText差不多。ConvertObject也是个递归过程：
procedure ConvertObject;
var
InheritedObject: Boolean;
begin
InheritedObject := False;
if Parser.TokenSymbolIs('INHERITED') then
InheritedObject := True
else
Parser.CheckTokenSymbol('OBJECT');
Parser.NextToken;
ConvertHeader(InheritedObject);
while not Parser.TokenSymbolIs('END') and
not Parser.TokenSymbolIs('OBJECT') and
not Parser.TokenSymbolIs('INHERITED') do ConvertProperty;
Writer.WriteListEnd;
while not Parser.TokenSymbolIs('END') do ConvertObject;
Writer.WriteListEnd;
Parser.NextToken;
end;
DFM文件与DFM脚本语言之间相互转换的任务由ObjectResourceToText和ObjextTextToResource两个过程完成。
procedure ObjectResourceToText(Input, Output: TStream);
begin
Input.ReadResHeader;
ObjectBinaryToText(Input, Output);
end;
ObjectTextToResource过程就比较复杂，因为DFM文件资源头中要包含继承标志信息，因此在调用ObjectTextToBinary后，就读取标志信息，然后写入资源头。
procedure ObjectTextToResource(Input, Output: TStream);
var
Len: Byte;
Tmp: Longint;
MemoryStream: TMemoryStream;
MemorySize: Longint;
Header: array[0..79] of Char;
begin
MemoryStream := TMemoryStream.Create;
try
ObjectTextToBinary(Input, MemoryStream);
MemorySize := MemoryStream.Size;
FillChar(Header, SizeOf(Header), 0);
MemoryStream.Position := SizeOf(Longint); { Skip header }
MemoryStream.Read(Len, 1);
if Len and $F0 = $F0 then
begin
if ffChildPos in TFilerFlags((Len and $F0)) then
begin
MemoryStream.Read(Len, 1);
case TValueType(Len) of
vaInt8: Len := 1;
vaInt16: Len := 2;
vaInt32: Len := 4;
end;
MemoryStream.Read(Tmp, Len);
end;
MemoryStream.Read(Len, 1);
end;
MemoryStream.Read(Header[3], Len);
StrUpper(@Header[3]);
Byte((@Header[0])^) := $FF;
Word((@Header[1])^) := 10;
Word((@Header[Len + 4])^) := $1030;
Longint((@Header[Len + 6])^) := MemorySize;
Output.Write(Header, Len + 10);
Output.Write(MemoryStream.Memory^, MemorySize);
finally
MemoryStream.Free;
end;
end;
20.3.1.5 动态DFM文件应用揭秘
1. 动态DFM文件概述
动态DFM文件是相对于静态DFM文件而言。所谓静态DFM文件是指在Delphi开发环境中设计的窗体文件。窗体的设计过程就是程序的编制过程。因此，动态DFM文件就是指在程序运行过程生成或存取的DFM文件。
动态DFM文件的创建和使用分别如下两种情况：
● 在程序运行过程中，由Create方法动态生成窗体或部件，然后动态生成其它部件插入其中生成DFM文件
● 在Delphi开发环境中，设计生成DFM文件，然后用DFM 文件存取函数，或者用Stream对象和Filer对象的方法，将DFM文件读入内存，进行处理，最后又存入磁盘中
由Delphi的窗体设计的常规方法生成的DFM文件在程序运行一开始就规定了部件的结构。因为在窗体设计过程中，窗体中的每个部件都在程序的对象声明中定义了部件变量。这种固定的结构虽然能方便应用，但以牺牲灵活性为代价。
在Delphi应用程序中有时需要在运行过程中创建控制，然后将该控制插入另一个部件中。例如：
procedure TForm1.Button1Click(Sender: Tobject);
var
Ctrl: TControl
begin
Ctrl := TEdit.Create(Self);
Ctrl.Top := 100;
Ctrl.Left := 100;
Ctrl.Width := 150;
Ctrl.Height := 20;
InsertControl(Ctrl);
end;
动态插入控制的优点是可以在任何时刻、任意位置插入任意数量的任何类型的控制。因为应用程序需求在很多情况下是在程序运行中才知道的，所以动态插入控制就显得很重要。而且在很多情况下，需要保存这些界面元素，留待程序再次调用。例如应用程序界面的定制、系统状态的保存、对话框的保存等。这时生成动态DFM文件是最佳选择。
动态插入控制的不足之处是在插入控制前，无法直观地看到控制的大小、风格、位置等，也就是动态插入控制的过程是非可视化的。但可以借助于静态DFM文件的可视化设计。这就是生成和使用动态DFM文件的第二种方法。也就是在应用程序运行前，在Delphi开发环境中，使用可视化开发工具设计所需窗口或部件的样式，以DFM文件保存。然后在应用程序运行过程中，将DFM文件读入内存。Delphi的Stream对象和Filer对象在读取DFM文件时，会根据DFM文件的内容自动创建部件及其拥有的所有部件。
在使用动态DFM文件时有两点需要注意。
● 每一个动态插入的控制或部件必须在程序中调用RegisterClass进行注册
● 读入DFM文件自动创建部件后，如果调用了InsertControl方法， 则在关闭窗口时要调用RemoveControl方法移去该控制，否则会产生异常事件
2. 动态DFM文件应用之一：超媒体系统的卡片设计
Delphi多种类型的可视部件，如文本部件、编辑部件、图形图像部件、数据库部件、媒体媒放部件和OLE部件等，每一种部件在屏幕中占据一定的区域，具有相当丰富的表现能力，可以作为卡片中的一种媒体，因此可以利用这些可视部件进行超媒体系统的卡片设计。
超媒体卡片设计要求卡片中的媒体数目和媒体种类是不受限制的，而且必须能够修改和存取卡片，因此，采用动态DFM文件是比较合适的。而且如果利用Stream对象，将卡片存储在数据库BLOB字段中，就为把超文本与关系数据库技术结合起来创造了契机。
下面是超媒体卡片设计子系统中的部分源程序，它演示了如何创建对象、插入对象和存取动态DFM文件。
⑴ 在应用程序中注册对象
procedure TMainForm.FormCreate(Sender: TObject);
begin
RegisterClass(TLabel);
RegisterClass(TEdit);
RegisterClass(TMemo);
RegisterClass(TButton);
RegisterClass(TPanel);
RegisterClass(TPanelP);
RegisterClass(TBitBtn);
…
end;
⑵ 创建和插入对象
procedure TMDIChild.FormClick(Sender: TObject);
var
Ctrl : TControl;
Point: TPoint;
begin
GetCursorPos(Point);
Point := BackGround.ScreenToClient(Point);
case CurToolIndex of
1 : begin
Ctrl := TLabel.Create(self);
TLabel(Ctrl).AutoSize := False;
TLabel(ctrl).Caption := 'Label'+S;
TLabel(ctrl).Name := 'Label 1';
TLabel(ctrl).Top := Point.Y;
TLabel(ctrl).Left := Point.X;
TLabel(Ctrl).Height := Round(100*Res/1000/Ratio);
TLabel(Ctrl).Width := Round(600*Res/1000/Ratio);
TLabel(Ctrl).Color := clWhite;
TLabel(Ctrl).Font.Color := clBlack;
TLabel(Ctrl).Font.Name := 'Roman';
TLabel(Ctrl).Font.Height := -TLabel(Ctrl).Height;
TLabel(Ctrl).Font.Pitch := fpFixed;
TLabel(Ctrl).Enabled := False;
TLabel(Ctrl).OnClick := LabelClick;
TLabel(Ctrl).OnMouseMove := ReportPos;
BackGround.InsertControl(Ctrl);
CurTool.Down := False;
CurTool := nil;
…
end;
2: begin
Ctrl := TEdit.Create(self);
TEdit(ctrl).AutoSize := True;
TEdit(ctrl).Top := Point.Y;
TEdit(ctrl).Left := Point.X;
TEdit(Ctrl).Height := 20;
BackGround.InsertControl(Ctrl);
…
end;
3:
…
end;
end;
⑵ 存取动态DFM文件
procedure TMainForm.FileOpen(Sender: TObject);
begin
if OpenDialog.Execute then
begin
DesignWin := TMDIChild.Create(Application);
ReadComponentResFile(OpenDialog.FileName, DesignWin);
DesignWin.Init;
FileName := OpenDialog.FileName;
DesignWin.Caption := FFileName;
end;
end;
DesignWin是在TMainForm中定义的TMDIChild类型的窗体部件，是卡片设计平台；FFileName是私有变量，用来保存当前编辑的卡片文件名。DesignWin的Init方法实现如下：
procedure TMDIChild.Init;
var
I: Integer;
Ctrl: TControl;
begin
BackGround.BringToFront;
with BackGround do
for I:= 0 to ControlCount - 1 do
if Controls[I].Name <> ''then
ObjectIns.ObjectList.Items.AddObject(Controls[I].Name, Controls[I]);
end;
BackGround是TPanel类型的部件，所有的动态创建对象都插入到BackGround中，所以，后面调用BackGround.InsertControl(Ctrl)；ObjectIns是个仿Delphi 的媒体属性编辑器。
动态DFM文件的存储过程是这样的：
procedure TMainForm.FileSave(Sender: TObject);
begin
if DesignWin.CurControl <> nil then
DesignWin.CurControl.Enabled := True;
WriteComponentResFile(FFilename, DesignWin);
DesignWin.Caption := FileName;
end;
end;
因为在DesignWin的Init方法中调用了InsertControl方法，所以在关闭DesignWin窗口时要相应地调用RemoveControl，否则在关闭DesignWin窗口时会产生内存错误。
procedure TMDIChild.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
var
I: Integer;
Ctrl: TControl;
Removed: Boolean;
begin
if Modified = True then
if MessageDlg('Close the form?', mtConfirmation,
[mbOk, mbCancel], 0) = mrCancel then
CanClose := False;
if CanClose = True then
begin
repeat
removed := False;
I := 0;
repeat
if BackGround.Controls[I].Name <> '' then
begin
BackGround.RemoveControl(BackGround.Controls[I]);
Removed := True;
end;
I := I + 1
until (I >= BackGround.ControlCount) or (Removed = True);
until (Removed = False);
SendMessage(ObjectIns.Handle, WM_MDICHILDCLOSED, 0, 0);
end;
end;
3. 动态DFM文件应用之二：超媒体系统脚本语言设计
超媒体脚本语言设计是超媒体系统设计的重要内容。脚本语言必须能够表达卡片中的多种媒体对象，必须是可编程，可理解的，必须是可执行的，应该可以由脚本语言生成超媒体系统中的卡片和链。
DFM文件可以看作是超媒体系统的卡片，DFM脚本能够表达DFM文件中的多种控制，也就是说能够表达卡片中的多种媒体对象，再加上DFM脚本的对象式表达，可编辑性，可转换为DFM文件，因此用作超媒体系统脚本语言较好的形式。
ObjectBinaryToText和ObjectTextToBinary过程提供了在部件和DFM脚本之间相互转化的功能，ObjectResourceToText和ObjectTextToResoure过程提供了DFM文件和DFM脚本之间相互转化的功能。这样就可以在应用程序中自如实现超媒体卡片和超媒体脚本语言相互转化。
下面是卡片和脚本语言相互转化的程序：
procedure TMDIChild.CardToScript;
var
In, Out: TStream;
begin
In := TMemoryStream.Create;
Out := TMemoryStream.Create;
try
In.WriteComponentRes(Self.ClassName, Self);
ObjectResourceToText(In, out);
ScriptForm.ScriptEdit.Lines.LoadFromStream(Out);
finally
In.Free;
Out.Free;
end;
end;
ScriptEdit是个文本编辑器，它的Lines属性是TStrings类型的对象。
procedure TScriptForm.ScriptToCard;
var
In, Out: TStream;
begin
In := TMemoryStream.Create;
Out := TMemoryStream.Create;
try
ScriptForm.ScriptEdit.Lines.SaveToFromStream(In);
ObjectTextToResource(In, out);
In.ReadComponentRes(DesignWin);
finally
In.Free;
Out.Free;
end;
end;
这两段程序是对整个卡片，即窗体级，进行转换的。ObjectBinaryToText和ObjectTextToBinary过程可以细化到部件级的转换。因此超媒体脚本语言的编辑可以细化到媒体对象级。
4. 超媒体编辑和表现系统与动态DFM文件的扩展
超媒体系统的媒体编辑与卡片管理有其特殊的需求，比如链接需求。这时采用已有的窗体部件和媒体部件并按常规的DFM文件处理就显得力不从心了。解决这个矛盾有两套方案：
● 利用Delphi部件开发技术，继承和开发新的部件增加新的超媒体特有的属性和处理方法
● 扩展DFM文件结构，使之能按自己的需要任意地存取和转换部件和DFM文件
前者是充分利用Delphi的面向对象部件开发技术，在存取和转换等处理上仍旧与常规DFM文件相同。而后者需要DFM的存取和转换上作比较大的改动。下文介绍扩展DFM文件的思路。
扩展动态DFM文件的总体思路是降低处理操作的数据的颗粒度，即从原先窗体级降低到部件级。
下面是存取操作的扩展示范：
var
FileStream: TStream;
I: Integer;
begin
FileStream := TFileStream.Create('OverView.Crd', fmOpenWrite);
With TWriter.Create(FileStream, 4096) do
try
for I := 0 to DesignWin.ControlCount - 1 do
begin
WriteInteger(MMID[i]);
WriteRootComponent(DesignWin.Controls[i]);
{ 写相应媒体扩展信息 }
……
end;
WriteListEnd;
finally.
Free;
end;
FileStream.Free;
end;
WriteInteger(MMID[i])语句是写入媒体标识。
下面是相应的读扩展DFM的程序：
var
PropInfo: PPropInfo;
Method : TMethod;
FileStream: TStream;
I: Integer;
begin
FileStream := TFileStream.Create('OverView.Crd', fmOpenRead);
With TReader.Create(FileStream, 4096) do
try
while not EndOfList do
begin
case ReadInteger of
IDText: begin
Ctrl := TControl(ReadRootComponent(nil));
PropInfo := GetPropInfo(Ctrl.ClassInfo, 'OnClick');
Method.Code:= Self.MethodAddress(MethodName);
Method.Data := Self;
if Method.Code <> nil then
SetMethodProp(Ctrl, PropInfo, Method);
DesignWin.InsertControl(Ctrl);
end;
IDImage:
……
end;
……
WriteListEnd;
end;
finally.
Free;
end;
FileStream.Free;
end;
SetMethodProp过程是用于重新联接控制和它的事件处理过程。类似的功能还可以用TReader对象的OnFindMethod事件的处理过程来实现。
实现脚本语言扩展的基本方法与存取扩展类似，但它还要加扩展媒体信息转换为文本，并插入到部件的脚本描述中。
20.3.2 数据库BLOB字段应用
Delphi VCL提供了TBlobStream对象支持对数据库BLOB字段的存取。Delphi 的TBlobStream对象的作用在于一方面可以使Delphi应用程序充分利用多媒体数据库的数据管理能力。另一方面又能利用Delphi Object Pascal的程序设计能力给关系型多媒体数据库提供底层控制能力和全方位的功能扩展余地。
20.3.2.1 TBlobStream的使用
TBlobStream对象用一个TBlobField类型的对象作为参数来创建与BLOB字段相联的BLOB流，接着就可用流的存取方法在BLOB字段中存取数据。
var
BlobStream: TBlobStream;
I: Integer;
begin
BlobStream := TBlobStream.Create(TBlobField(CardTable.Fields[10], bmWrite);
With TWriter.Create(BlobStream, 4096) do
try
for I := 0 to DesignWin.ControlCount - 1 do
begin
WriteInteger(MMID[i]);
WriteRootComponent(DesignWin.Controls[i]);
{ 写相应媒体扩展信息 }
……
end;
WriteListEnd;
finally.
Free;
end;
BlobStream.Free;
CardTable.Post;
end;
Fields变量是表示数据库记录的字段数组，Fields[10]正是数据库的BLOB 字段。CardTable的Post方法将数据库的修改反馈到数据库的物理存储上。
上面这段程序是超媒体卡片存储的部分源程序，我们就是将卡片保存在数据库BLOB字段中，实现将超文本和关系数据库两种数据管理方式结合起来。读卡片的程序如下：
var
PropInfo: PPropInfo;
Method: TMethod;
Blobtream: TStream;
I: Integer;
begin
BlobStream := TBlobStream.Create(TBlobField(CardTable.Fields[10]), bmRead);
With TReader.Create(BlobStream, 4096) do
try
while not EndOfList do
begin
case ReadInteger of
IDText: begin
Ctrl := TControl(ReadRootComponent(nil));
PropInfo := GetPropInfo(Ctrl.ClassInfo, 'OnClick');
Method.Code:= Self.MethodAddress(MethodName);
Method.Data := Self;
if Method.Code <> nil then
SetMethodProp(Ctrl, PropInfo, Method);
DesignWin.InsertControl(Ctrl);
end;
IDImage:
……
end;
……
WriteListEnd;
end;
finally.
Free;
end;
FileStream.Free;
end;
20.3.2.2 BLOB字段与图形图像
在多媒体数据库中处理得比较多的是图形图像，因此早期的多媒体数据库在扩展关系数据库时往往是增加一个图像字段。BLOB字段是以二进制数据存储方式，因此它完全可以表达图形图像数据。
在TBlobField对象中提供了LoadFromBitMap和SaveToBitMap方法存取位图数据。它们在实现上都是使用BlobStream对象。
procedure TBlobField.LoadFromBitmap(Bitmap: TBitmap);
var
BlobStream: TBlobStream;
Header: TGraphicHeader;
begin
BlobStream := TBlobStream.Create(Self, bmWrite);
try
if (DataType = ftGraphic) or (DataType = ftTypedBinary) then
begin
Header.Count := 1;
Header.HType := $0100;
Header.Size := 0;
BlobStream.Write(Header, SizeOf(Header));
Bitmap.SaveToStream(BlobStream);
Header.Size := BlobStream.Position - SizeOf(Header);
BlobStream.Position := 0;
BlobStream.Write(Header, SizeOf(Header));
end else
Bitmap.SaveToStream(BlobStream);
finally
BlobStream.Free;
end;
end;
procedure TBlobField.SaveToBitmap(Bitmap: TBitmap);
var
BlobStream: TBlobStream;
Size: Longint;
Header: TGraphicHeader;
begin
BlobStream := TBlobStream.Create(Self, bmRead);
try
Size := BlobStream.Size;
if Size >= SizeOf(TGraphicHeader) then
begin
BlobStream.Read(Header, SizeOf(Header));
if (Header.Count <> 1) or (Header.HType <> $0100) or
(Header.Size <> Size - SizeOf(Header)) then
BlobStream.Position := 0;
end;
Bitmap.LoadFromStream(BlobStream);
finally
BlobStream.Free;
end;
end;
程序中按两种方式存取数据，对于位图数据，数据的起点是流的Potition为0处，对于图形或其它类型的Blob数据，则以流的Position为SizeOf(Header) + 1处开始， 即多了个头信息。
20.3.2.3 BLOB字段与文本
Delphi BLOB字段中增加了大型文本的处理能力。可以在TBlobField和Strings中自由地交换数据。
procedure TBlobField.LoadFromStrings(Strings: TStrings);
var
BlobStream: TBlobStream;
begin
BlobStream := TBlobStream.Create(Self, bmWrite);
try
Strings.SaveToStream(BlobStream);
finally
BlobStream.Free;
end;
end;
procedure TBlobField.SaveToStrings(Strings: TStrings);
var
BlobStream: TBlobStream;
begin
BlobStream := TBlobStream.Create(Self, bmRead);
try
Strings.LoadFromStream(BlobStream);
finally
BlobStream.Free;
end;
end;
20.3.2.4 BLOB字段与Stream对象
因为Delphi中，BLOB字段是通过BLOB流来访问的，所以可以很容易地在BLOB字段和Stream对象之间传递数据。为此，TBlobField对象提供了LoadFromStream和SaveToStream方法。
procedure TBlobField.LoadFromStream(Stream: TStream);
var
BlobStream: TBlobStream;
begin
BlobStream := TBlobStream.Create(Self, bmWrite);
try
BlobStream.CopyFrom(Stream, 0);
finally
BlobStream.Free;
end;
end;
procedure TBlobField.SaveToStream(Stream: TStream);
var
BlobStream: TBlobStream;
begin
BlobStream := TBlobStream.Create(Self, bmRead);
try
Stream.CopyFrom(BlobStream, 0);
finally
BlobStream.Free;
end;
end;
20.3.3 存取嵌入在OleContainer对象中的OLE服务器的数据
对象链接和嵌入(Object Linking and Embedding，简称OLE)，是一组服务功能，它提供了一种用来源于不同应用程序的信息创建复合文档的强有力方法。
通过把图像、图形、表格、声音、注解、文件和其它表示手段描述成对象，用它能在不同软件厂家提供的应用程序中更为容易地交换合成和处理数据它是应用程序的集成更为容易。OLE2.0支持直观编辑。用户不需切换到不同窗口就能在文档中直接对对象进行操作，改进了操作环境。用户不用再关注应用程序和操作环境，只需关注于使用对象技术的数据和文件，便能完成全部工作。
OLE已成为操作系统功能上的一大标准，各大软商纷纷在开发工具中支持OLE 2.0规范。Delphi 2.0提供了OleContainer对象支持OLE窗户应用程序的开发。
尽管通过OLE可以用来源于不同应用程序的信息创建复合文档，充分体现以任务、以文档为中心的思想，但是很难分解来自其它应用程序中的嵌入数据，以进行特殊的处理。
例如，一套多媒体电子文档管理系统，系统需要数据库管理功能文档编辑功能，全文检索功能等。在文档编辑功能的实现上，如果能利用中文Word 或写字板之类的强大的编辑排版功能，就可以省却重新开发一个文档编辑的费用，使用具有直观编辑的OLE复合文档嵌入Word的DOC数据或RTF数据当然是最佳的选择。 但问题在于全文检索系统要求能直接在文档中搜索关键字，因此要求将文档数据从OLE嵌入数据或文档中的本地数据中分离出来。
Delphi 2.0的OleContainer部件支持存储OLE对象数据。OLE对象数据包括两部分：OLE类描述信息和OLE服务器嵌入数据。一般说来，OLE服务器嵌入数据是以服务器支持的数据格式存储的; 比方说，中文Word 6.0的嵌入数据的格式就是Word 6.0文档的格式。因此，要将文档数据从OLE 嵌入式文档中分离出来就是要访问第二部分数据。
我们分析了Delphi 2.0的OleContainer对象存取复合文档的程序，得到分离数据的方法。
让我们来看一段OleContainer对象存储数据的程序：
procedure TOleContainer.SaveToStream(Stream: TStream);
var
DataHandle: HGlobal;
Buffer: Pointer;
Header: TStreamHeader;
R: TRect;
……
begin
……
try
……
if FOldStreamFormat then
begin
R := BoundsRect;
Header.PartRect.Left := R.Left;
Header.PartRect.Top := R.Top;
Header.PartRect.Right := R.Right;
Header.PartRect.Bottom := R.Bottom;
end else
begin
Header.Signature := StreamSignature;
Header.DrawAspect := FDrawAspect;
end;
Header.DataSize := GlobalSize(DataHandle);
Stream.WriteBuffer(Header, SizeOf(Header));
Buffer := GlobalLock(DataHandle);
try
Stream.WriteBuffer(Buffer^, Header.DataSize);
finally
GlobalUnlock(DataHandle);
end;
finally
ReleaseObject(TempStorage);
ReleaseObject(TempLockBytes);
end;
end;
程序中，OleContainer对象执行了两次往流中写数据的操作。
Stream.WriteBuffer(Header, Size(Header));
Stream.WriteBuffer(Buffer^, Header.DataSize);
前一语句是写入OLE类描述信息，后一句语句是写入OLE服务器的嵌入数据。Header是TStreamHeader记录类型的变量。TStreamHeader记录的定义如下：
TStreamHeader = record
case Integer of
0: ( { 新版OLE对象 }
Signature: Integer;
DrawAspect: Integer;
DataSize: Integer);
1: ( { 旧版OLE对象 }
PartRect: TSmallRect);
end;
因此读OLE服务器嵌入数据时，要跳过文件头的TStreamHeader记录。下面就是如何分离OLE服务器嵌入数据的程序：
var
Stream : TMemoryStream;
FileStream : TFileStream;
begin
Stream := TMemoryStream.Create;
FileStream := TFileStream.Create('TEST.DOC', fmCreate) ;
with OleContainer1 do
if (State <> osEmpty) then
SaveToStream(Stream)
Stream.Seek(Sizeof(TStreamHeader), 0);
FileStream.CopyFrom(Stream, Stream.Size - SizeOf(TStreamHeader));
Stream.Free;
FileStream.Free;
end;
OleContainer1包含的服务器对象是中文Word 6.0，程序中将分离出的数据存储在磁盘文件“TEST.DOC”上。如果希望存储在不同的媒介上，可以使用相应的Stream对象，分离的方法类似。但是，这种方法并非对所有的OLE服务器数据都适用，如Windows 95 附件中的写字板（WordPad）就不行。
（jun 初级教程完）
1550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
