Delphi 2010：如何将整条记录保存到文件中？

Question

我已经定义了一个记录，其中包含许多不同类型的字段（整数、实数、字符串、...加上“...的数组”方面的动态数组）。 我想将它作为一个整体保存到一个文件中，然后能够将它加载回我的程序。我不想单独保存每个字段的值。 文件类型（二进制或 ascii 或 ...）并不重要，只要 Delphi 可以将其读回记录即可。

你有什么建议吗？

Answer 1

只要不使用动态数组，您就可以直接从流中加载和保存记录的内存。所以如果你使用字符串，你需要将它们固定：

type TTestRecord = record 
  FMyString : string[20]; 
end; 

var 
  rTestRecord: TTestRecord;
  strm : TMemoryStream; 

strm.Write(rTestRecord, Sizeof(TTestRecord) );

您甚至可以一次加载或保存一组记录！

type TRecordArray = array of TTestRecord;

var ra : TRecordArray; 

strm.Write(ra[0], SizeOf(TTestRecord) * Length(ra));

如果你想写动态内容：

iCount   := Length(aArray);
strm.Write(iCount, Sizeof(iCount) );      //first write our length
strm.Write(aArray[0], SizeOf * iCount);   //then write content

之后，你可以回读：

strm.Read(iCount, Sizeof(iCount) );       //first read the length
SetLength(aArray, iCount);                //then alloc mem
strm.Read(aArray[0], SizeOf * iCount);    //then read content

Answer 2

这里承诺的是：https://github.com/KrystianBigaj/kblib

当你定义例如记录为：

TTestRecord = record
  I: Integer;
  D: Double;
  U: UnicodeString;
  W: WideString;
  A: AnsiString;
  Options: TKBDynamicOptions;

  IA: array[0..2] of Integer;

  AI: TIntegerDynArray;
  AD: TDoubleDynArray;
  AU: array of UnicodeString;
  AW: TWideStringDynArray;
  AA: array of AnsiString;

  R: array of TTestRecord; // record contain dynamic array of itself (D2009+)
end;

您可以通过以下方式将整个动态记录保存到流（作为二进制数据）：

TKBDynamic.WriteTo(lStream, lTestRecord, TypeInfo(TTestRecord));

要加载它：

TKBDynamic.ReadFrom(lStream, lTestRecord, TypeInfo(TTestRecord));

它不需要是记录，你可以对任何动态类型做同样的事情，比如：

TKBDynamic.WriteTo(lStream, lStr, TypeInfo(UnicodeString));
TKBDynamic.WriteTo(lStream, lInts, TypeInfo(TIntegerDynArray));
TKBDynamic.WriteTo(lStream, lArrayOfTestRecord, TypeInfo(TArrayOfTestRecord)); // TArrayOfTestRecord = array of TTestRecord;

在 Delphi 2006/2009/XE 上测试。许可证：MPL 1.1/GPL 2.0/LGPL 3.0 有关信息，请参阅自述文件。

Answer 3

另一个非常适合记录的选项（Delphi 2010+）是使用SuperObject 库。例如：

type
  TData = record
    str: string;
    int: Integer;
    bool: Boolean;
    flt: Double;
  end;
var
  ctx: TSuperRttiContext;
  data: TData;
  obj: ISuperObject;
  sValue : string;
begin
  ctx := TSuperRttiContext.Create;
  try
    sValue := '{str: "foo", int: 123, bool: true, flt: 1.23}';
    data := ctx.AsType<TData>(SO(sValue));
    obj := ctx.AsJson<TData>(data);
    sValue := Obj.AsJson;
  finally
    ctx.Free;
  end;
end;

我还用一个简单的TArray<Integer> 动态数组对此进行了简单的测试，它在存储和加载数组元素时没有问题。

Answer 4

除了说明您如何执行此操作的答案外，还请注意以下事项：

1. 您必须注意，将记录写入文件将是特定于 Delphi 版本的（通常：特定于为底层数据类型共享相同内存布局的一系列 Delphi 版本）。

2. 只有当您的记录不包含托管类型的字段时，您才能这样做。这意味着字段不能属于以下托管类型：strings、动态数组、variants 和引用类型（如 pointers、procedural types、method references、interfaces 或 classes）和文件类型，或包含这些管理类型的类型。基本上仅限于这些非托管类型：

   • 答：Simple types（包括字节、整数、浮点数、枚举、字符等）
   • 乙：Short strings
   • C：套装
   • D：A、B、C、D 和 E 的静态数组
   • E：A、B、C、D 和 E 的记录

与其将记录写入文件或从文件中写入记录，不如使用类实例并将它们转换为 JSON 或从 JSON 转换它们，然后它们写入与文件等效的 JSON 字符串并将其读回。

您可以使用这个单元为您进行 JSON 转换（应该适用于 Delphi 2010 及更高版本；肯定适用于 Delphi XE 及更高版本）来自this locationthis location。

unit BaseObject;

interface

uses DBXJSON, DBXJSONReflect;

type
  TBaseObject = class
  public
    { public declarations }
    class function ObjectToJSON<T : class>(myObject: T): TJSONValue;
    class function JSONToObject<T : class>(json: TJSONValue): T;
  end;

implementation

{ TBaseObject }

class function TBaseObject.JSONToObject<T>(json: TJSONValue): T;
var
  unm: TJSONUnMarshal;
begin
  if json is TJSONNull then
    exit(nil);
  unm := TJSONUnMarshal.Create;
  try
    exit(T(unm.Unmarshal(json)))
  finally
    unm.Free;
  end;

end;

class function TBaseObject.ObjectToJSON<T>(myObject: T): TJSONValue;
var
  m: TJSONMarshal;
begin

  if Assigned(myObject) then
  begin
    m := TJSONMarshal.Create(TJSONConverter.Create);
    try
      exit(m.Marshal(myObject));
    finally
      m.Free;
    end;
  end
  else
    exit(TJSONNull.Create);

end;

end.

我希望这可以帮助您了解事物的概况。

--杰罗恩

Answer 5

您还可以定义一个对象而不是记录，因此您可以使用 RTTI 将您的对象保存为 XML 或其他格式。如果你有 D2010 或 XE，你可以使用 DeHL 对其进行序列化： Delphi 2010 DeHL Serialization XML and custom attribute : how it work?

但是如果你“谷歌”你可以找到其他带有 RTTI 和序列化的库（使用 D2007 等）

Answer 6

另一个解决方案，从 Delphi 5 到 XE，可用as an OpenSource unit。

其实它实现了：

• 一些用于处理记录类型的低级 RTTI 函数：RecordEquals, RecordSave, RecordSaveLength, RecordLoad;
• 专用的TDynArray 对象，它是任何动态数组的包装器，能够在任何动态数组周围公开类似TList 的方法，甚至包含记录、字符串或其他动态数组。它能够序列化任何动态数组。

序列化使用优化的二进制格式，可以将任何记录或动态数组保存和加载为RawByteString。

我们在 ORM 中使用它，将动态数组属性等高级类型存储到数据库后端。第一步到DB-Sharding architecture。

Answer 7

如果您有动态字符串或数组，则不能“作为一个整体”写入记录。我不会使用旧式最多 25 个字符的字符串，而是向记录添加方法，以便能够将自身“流式传输”到流中，或者更好地使用 TFiler 后代：

TMyRec = record
  A: string;
  B: Integer;
  procedure Read(AReader: TReader);
  procedure Writer(AWriter: TWriter);
end;

procedure TMyrec.Read(AReader: TReader);
begin
  A := AReader.ReadString;
  B := AReader.ReadInteger;
end;

Answer 8

来自delphibasics的代码：

 type
   TCustomer = Record
     name : string[20];
     age  : Integer;
     male : Boolean;
   end;

 var
   myFile   : File of TCustomer;  // A file of customer records
   customer : TCustomer;          // A customer record variable

 begin
   // Try to open the Test.cus binary file for writing to
   AssignFile(myFile, 'Test.cus');
   ReWrite(myFile);

   // Write a couple of customer records to the file
   customer.name := 'Fred Bloggs';
   customer.age  := 21;
   customer.male := true;
   Write(myFile, customer);

   customer.name := 'Jane Turner';
   customer.age  := 45;
   customer.male := false;
   Write(myFile, customer);

   // Close the file
   CloseFile(myFile);

   // Reopen the file in read only mode
   FileMode := fmOpenRead;
   Reset(myFile);

   // Display the file contents
   while not Eof(myFile) do
   begin
     Read(myFile, customer);
     if customer.male
     then ShowMessage('Man with name '+customer.name+
                      ' is '+IntToStr(customer.age))
     else ShowMessage('Lady with name '+customer.name+
                      ' is '+IntToStr(customer.age));
   end;

   // Close the file for the last time
   CloseFile(myFile);
 end;

Answer 9

保存包含动态数组或真实字符串（或其他“托管”类型）的记录的问题在于，它不是包含所有内容的大内存块，它更像是一棵树。有人或某事需要以某种方式检查所有内容并将其保存到存储中。其他语言（例如 Python）包括各种将大多数对象转换为文本（序列化）、保存到磁盘并重新加载（反序列化）的工具。

尽管 Delphi 不存在 Embarcadero 提供的解决方案，但可以使用 Delphi 2010 中提供的扩展 RTTI 来实现。DeHL 库(here's a blog post about it) 中提供了现成的实现 - 但我不能多说实现，我没用过DeHL。

另一个选项是您要避免的：手动将记录序列化为 TStream；这实际上并不难。以下是我通常用于将对象读/写到文件流的代码：

procedure SaveToFile(FileName:string);
var F:TFileStream;
    W:TWriter;
    i:Integer;
begin
  F := TFileStream.Create(FileName, fmCreate);
  try
    W := TWriter.Create(F, 128);
    try
      // For every field that needs saving:
      W.WriteString(SomeStr);
      W.WriteInteger(TheNumber);
      // Dynamic arrays? Save the length first, then save
      // every item. The length is needed when reading.
      W.WriteInteger(Length(DArray));              
      for i:=0 to High(DArray) do
        W.WriteString(DArray[i]);
    finally W.Free;
    end;
  finally F.Free;
  end;
end;

procedure ReadFromFile(FileName:string);
var F:TFileStream;
    R:TReader;
    i,n:Integer;
begin
  F := TFileStream.Create(FileName, fmOpenRead);
  try
    R := TReader.Create(F, 128);
    try
      SomeStr := R.ReadString;
      TheNumber := R.ReadInteger;
      // Reading the dynamic-array. We first get the length:
      n := R.ReadInteger;
      SetLength(DArray, n);
      // And item-by-item
      for i:=0 to n-1 do
        DArray[i] := R.ReadString;
    finally R.Free;
    end;    
  finally F.Free;
  end;
end;