Delphi T 记录列表

Question

我需要存储临时记录列表，并且认为 TList 是实现此目的的好方法？但是我不确定如何使用 TList 执行此操作，并且想知道这是否是最好的，以及是否有人有任何如何执行此操作的示例？

Answer 1

最简单的方法是创建您自己的 TList 后代。下面是一个用于演示的快速示例控制台应用程序：

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils, Classes;

type
  PMyRec=^TMyRec;
  TMyRec=record
    Value: Integer;
    AByte: Byte;
  end;

  TMyRecList=class(TList)
  private
    function Get(Index: Integer): PMyRec;
  public
    destructor Destroy; override;
    function Add(Value: PMyRec): Integer;
    property Items[Index: Integer]: PMyRec read Get; default;
  end;

{ TMyRecList }

function TMyRecList.Add(Value: PMyRec): Integer;
begin
  Result := inherited Add(Value);
end;

destructor TMyRecList.Destroy;
var
  i: Integer;
begin
  for i := 0 to Count - 1 do
    FreeMem(Items[i]);
  inherited;
end;

function TMyRecList.Get(Index: Integer): PMyRec;
begin
  Result := PMyRec(inherited Get(Index));
end;

var
  MyRecList: TMyRecList;
  MyRec: PMyRec;
  tmp: Integer;
begin
  MyRecList := TMyRecList.Create;
  for tmp := 0 to 9 do
  begin
    GetMem(MyRec, SizeOf(TMyRec));
    MyRec.Value := tmp;
    MyRec.AByte := Byte(tmp);
    MyRecList.Add(MyRec);
  end;

  for tmp := 0 to MyRecList.Count - 1 do
    Writeln('Value: ', MyRecList[tmp].Value, ' AByte: ', MyRecList[tmp].AByte);
  WriteLn('  Press Enter to free the list');
  ReadLn;
  MyRecList.Free;
end.

这消除了一些事情：

• 它负责释放内存。
• 您不必输入所有内容即可使用它。

正如雷米和沃伦所说，这需要更多的工作，因为在添加新记录时必须分配内存。

Answer 2

首先，如果您想将经典 TList 与记录结合起来，您将需要：

1. 在堆上分配记录，而不是在堆栈上。像 Remy 一样使用 GetMem。
2. 获取记录的地址并将其添加到 TList 中。
3. 当从列表中删除一个项目并使用它时，取消引用它：
4. 记住随后释放并清理。

将列表与记录结合起来需要大量的“指针和堆管理”工作，以至于这种技术只有专家才能做到。

您所要求的替代方案仍然使用称为“TList”的东西，包括使用 generics.collections 样式的 TList 和 Record 类型，这将具有 TList 的所有优点，但需要您基本上做很多完整的事情 -记录副本以将数据放入其中。

完成您所要求的操作的最惯用的 Delphi 方法是：

1. 使用带有类类型的 TList 或 TObjectList 而不是记录。在这种情况下，通常您最终会子类化 TList 或 TObjectList。

2. 动态记录类型数组，但请注意，对数组类型进行排序比较困难，并且在运行时扩展数组类型并不像使用 TList 那样快。

3. 在您的类中使用 generics.Collections TList。这可以让您避免每次想要使用具有不同类的列表时对 TList 或 TObjectList 进行子类化。

显示动态数组的代码示例：

 TMyRec = record
    ///
 end;

 TMyRecArray = array of TMyRec;

 procedure Demo;
 var
    myRecArray:TMyRecArray;
 begin
    SetLength(myRecArray,10);
 end;

现在了解一些关于为什么 TList 不容易与 Record 类型一起使用的背景信息：

TList 更适合与 Class 类型一起使用，因为类型为 'TMyClass' 的变量，其中 'type TMyClass = class 。 ... 结尾;'可以很容易地“引用”为指针值，这就是 TList 所保存的内容。

Record 类型的变量是 Delphi 中的值类型，而类值是隐式的引用值。您可以将引用值视为隐形指针。您不必取消引用它们即可获取其内容，但是当您将其添加到 TList 时，实际上只是添加了指向 TList 的指针，而不是进行复制或分配任何新内存。

雷米的答案从字面上向您展示了如何准确做您想做的事情，我写下我的答案只是因为我想警告您您所问问题的细节，并建议您考虑也有替代品。

Answer 3

您可以查看我们的 TDynArray 包装器。它在开源单元中定义，适用于 Delphi 6 到 XE。

借助 TDynArray，您可以使用 TList< 访问任何动态数组（例如 TIntegerDynArray = 整数数组 或 TRecordDynArray = TMyRecord 数组） /code> 类似的属性和方法，例如 Count、Add、Insert、Delete、Clear、IndexOf、Find、Sort 以及一些新方法，例如 LoadFromStream、SaveToStream、LoadFrom 和SaveTo 允许对任何动态数组进行快速二进制序列化，甚至包含字符串或记录 - 还可以使用 CreateOrderedIndex 方法根据动态数组内容创建单独的索引。如果您愿意，还可以将数组内容序列化为 JSON。还可以使用Slice、Reverse 或Copy 方法。

它将处理记录的动态数组，甚至记录中的记录，其中包含字符串或其他动态数组。

使用外部 Count 变量时，您可以大大加快在引用的动态数组中添加元素的速度。

type
  TPerson = packed record
    sCountry: string;
    sFullName: string;
    sAddress: string;
    sCity: string;
    sEmployer: string;
  end;
  TPersons = array of TPerson;
var
  MyPeople: TPersons;

(...)
procedure SavePeopleToStream(Stream: TMemoryStream);
var aPeople: TPerson;
    aDynArray: TDynArray;
begin
  aDynArray.Init(TypeInfo(TPersons),MyPeople);
  aPeople.sCountry := 'France';
  aPeople.sEmployer := 'Republique';
  aDynArray.Add(aPeople);
  aDynArray.SaveToStream(Stream);
end; // no try..finally Free needed here

还有一个 TDynArrayHashed 类，它允许对动态数组内容进行内部哈希处理。它非常快并且能够对任何类型的数据进行散列（有用于字符串的标准散列器，但您可以提供自己的 - 甚至散列函数也可以自定义）。

请注意，TDynArray 和 TDynArrayHashed 只是现有动态数组变量的包装器。因此，您可以根据需要初始化 TDynArray 包装器，以更有效地访问任何本机 Delphi 动态数组。

Answer 4

您可以使用 TList 来实现此目的，例如：

type
  pRec = ^sRec;
  sRec = record
    Value: Integer;
    ...
  end;

var
  List: TList;
  Rec: pRec;
  I: Integer;
begin
  List := TList.Create;
  try
    for I := 1 to 5 do begin
      GetMem(Rec);
      try
        Rec^.Value := ...;
        ...
        List.Add(Rec);
      except
        FreeMem(Rec);
        raise;
      end;
    end;
    ...
    for I := 0 to List.Count-1 do
    begin
      Rec := pRec(List[I]);
      ...
    end;
    ...
    for I := 0 to List.Count-1 do
      FreeMem(pRec(List[I]));
    List.Clear;
  finally
    List.Free;
  end;
end;

Answer 5

使用 System.Generics.Collections 中的 Generiс TList。
如果您需要通过引用访问通用 TList 中的记录并且不复制记录：
使用List.List - 直接访问TList数组。

MyList := TList<TTestRec>.Create; 
[...] 

var lRecP: PTestRec; // (PTestRec = ^TTestRec)
lRecP := @MyList.List[i]; 

现在您可以访问 Tlist 数组中的记录而无需复制它。

Answer 6

如果使用不存在泛型的旧版本 Delphi，请考虑从 TList 继承并覆盖 Notify 方法。添加项目时，分配内存，复制添加的指针内存内容并覆盖列表中的内容。删除时，只需释放内存即可。

  TOwnedList = class(TList)
  private
    FPtrSize: integer;
  protected
    procedure Notify(Ptr: Pointer; Action: TListNotification); override;
  public
    constructor Create(const APtrSize: integer);
  end;

  constructor TOwnedList.Create(const APtrSize: integer);
  begin
    inherited Create();
    FPtrSize := APtrSize;
  end;

  procedure TOwnedList.Notify(Ptr: Pointer; Action: TListNotification);
  var
    LPtr: Pointer;
  begin
    inherited;
    if (Action = lnAdded) then begin
      GetMem(LPtr, FPtrSize);
      CopyMemory(LPtr, Ptr, FPtrSize); //May use another copy kind
      List^[IndexOf(Ptr)] := LPtr;
    end else if (Action = lnDeleted) then begin
      FreeMem(Ptr, FPtrSize);
    end;
  end;

用法：

...
LList := TOwnedList.Create(SizeOf(*YOUR RECORD TYPE HERE*));
LList.Add(*YOU RECORD POINTER HERE*);
...

• 请注意，我使用 CopyMemory(LPtr, Ptr, FPtrSize) 的地方，您可以使用另一种复制方法。我的列表旨在存储带有指针引用的记录，因此它不管理其字段内存。

Answer 7

这完全取决于您要存储的数据类型。

您可以考虑使用 TCollection 和 TCollectionItem。

这是来自工作单元的（编辑）代码，其中我使用 TCollection 从文件夹中读取报告定义列表。每个报告都包含一种模板和一条 SQL 语句，必须与文件名一起存储。

由于它是经过编辑的，并且使用了我自己的一些单元（TedlFolderRtns 将文件读取到内部列表中，仅举一个例子），因此该示例足够简单且有用。通过少数替换全部，您可以适应您的任何需求。

在帮助中查找TCollection，你可以用它做很多事情。它可以让您的代码处理很好地分组在类似类的结构中。

  unit cReports;
  interface
  uses
     SysUtils, Classes, XMLDoc, XMLIntf, Variants,
     // dlib - Edelcom
     eIntList, eProgSettings,eFolder ;
  type

     TReportDefItem = class(TCollectionItem)
     private
        fSql: string;
        fSkeleton: string;
        fFileName: string;
        procedure Load;
        procedure SetFileName(const Value: string);
     public
        constructor Create(Collection:TCollection); override;
        destructor Destroy ; override;

        property FileName: string read fFileName write SetFileName;
        property Sql : string read fSql write fSql;
        property Skeleton : string read fSkeleton write fSkeleton;
     end;

     TReportDefList = class(TCollection)
     private
        function OsReportFolder: string;
        function GetAction(const Index: integer): TReportDefItem;
     public
        constructor Create(ItemClass: TCollectionItemClass);
        destructor Destroy; override;

        procedure LoadList;

        function Add : TReportDefItem;
        property Action [ const Index:integer ]: TReportDefItem read GetAction;
     end;

  implementation

  { TReportDefList }

  constructor TReportDefList.Create(ItemClass: TCollectionItemClass);
  begin
     inherited;
  end;

  destructor TReportDefList.Destroy;
  begin
     inherited;
  end;
  function TReportDefList.Add: TReportDefItem;
  begin
     Result := TReportDefItem( Add() );
  end;

  function TReportDefList.GetAction(const Index: integer): TReportDefItem;
  begin
     if (Index >= 0) and (Index < Count)
     then Result := TReportDefItem( Items[Index] )
     else Result := Nil;
  end;

  procedure TReportDefList.LoadList;
  var Folder : TedlFolderRtns;
      i : integer;
      Itm : TReportDefItem;
  begin
     Folder := TedlFolderRtns.Create;
     try
        Folder.FileList( OsReportFolder,'*.sw.xml', False);
        for i := 0 to Folder.ResultListCount -1 do
        begin
          Itm := Add();
          Itm.FileName := Folder.ResultList[i];
        end;
     finally
        FreeAndNil(Folder);
     end;
  end;

  function TReportDefList.OsReportFolder: string;
  begin
     Result := Application.ExeName + '_RprtDef';
  end;

  { TReportDefItem }

  constructor TReportDefItem.Create(Collection: TCollection);
  begin
     inherited;
     fSql := '';
     fSkeleton := '';
  end;

  destructor TReportDefItem.Destroy;
  begin
    inherited;
  end;

  procedure TReportDefItem.Load;
  var XMLDoc : IXMLDocument;
      TopNode : IXMLNode;
      FileNode : IXmlNode;
      iWebIndex, iRemoteIndex : integer;
      sWebVersion, sRemoteVersion: string;
      sWebFileName: string;
  begin
     if not FileExists(fFileName ) then Exit;

     XMLDoc := TXMLDocument.Create(nil);
     try
        XMLDoc.LoadFromFile( fFileName );
        XMLDoc.Active := True;

        TopNode := XMLDoc.ChildNodes.FindNode('sw-report-def');
        if not Assigned(TopNode) then Exit;

        FileNode := TopNode.ChildNodes.First;
        while Assigned(FileNode) do
        begin
           fSql := VarToStr( FileNode.Attributes['sql'] );
           fSkeleton := VarToStr(  FileNode.Attributes['skeleton'] );
           FileNode := FileNode.NextSibling;
        end;
        XMLDoc.Active := False;
     finally
        XMLDoc := Nil;
     end;
  end;

  procedure TReportDefItem.SetFileName(const Value: string);
  begin
     if fFileName <> Value
     then begin
        fFileName := Value;
        Load;
     end;
  end;
  end.

用作：

fReports := TReportDefList.Create( TReportDefItem );
fReports.LoadList();

Answer 8

我们刚刚在通用记录列表中遇到了类似的问题。希望以下伪代码有所帮助。

type
  PPat = ^TPat;
  TPat = record
    data: integer;
  end;

...
var
    AList: TList<PPat>;

...
procedure TForm1.Button1Click(Sender: TObject);
var
  obj: PPat;
begin
  obj := AList[0];
  obj.data := 1;
  Assert(obj.data = AList[0].data);  // correct
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  obj: PPat;
begin
  AList := TList<PPat>.Create;
  GetMem(obj, SizeOf(TPat));  // not shown but need to FreeMem when items are removed from the list
  obj.data := 2;
  AList.Add(obj);
end;