Delphi TList de registros

record

Question

Necesito almacenar una lista temporal de registros y estaba pensando que un TList sería una buena forma de hacerlo. Sin embargo, no estoy seguro de cómo hacer esto con un TList y me preguntaba si esto es lo mejor y si alguien tiene algún ejemplo de cómo hacerlo.

Answer 1

Acabamos de encontrarnos con un problema similar aquí con una lista genérica de registros. Espero que el siguiente código psuedo ayude.

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;

Answer 2

La forma más fácil es crear tu propio descendiente de TList . Aquí hay una aplicación de consola de muestra rápida para demostrar:

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.

Esto elimina un par de cosas:

• Se encarga de liberar la memoria.
• No tiene que encasillar todo para usarlo.

Como dijeron Remy y Warren, es un poco más de trabajo porque tienes que asignar la memoria cuando agregas nuevos registros.

Answer 3

Primero, si quiere combinar un TList clásico con Registros, necesitará:

1. Asigna tus registros en el montón, no en la pila. Usa GetMem como lo hizo Remy.
2. Tome la dirección del registro y agréguelo al TList.
3. Al eliminar un elemento de la lista y usarlo, desreferenciarlo:
4. Recuerde liberar y limpiar, después.

Combinar Listas con Registros requiere tanto trabajo de "punteros y heap-management" que tal técnica solo estaría dentro de las capacidades de un experto.

Las alternativas a lo que ha solicitado que todavía usan algo llamado "TList" incluyen el uso de un estilo genist.collections TList, con tipos de registros, que tendrían todos los beneficios de TList, pero requeriría básicamente hacer un montón de copias de registro para obtener datos en él.

Las formas más idiomáticas de Delphi para hacer lo que pides son:

1. use un TList o TObjectList con un tipo de clase en lugar de un registro. Normalmente terminas subclasando TList o TObjectList en este caso.

2. Utilice una matriz dinámica de tipos de registros, pero tenga en cuenta que es más difícil ordenar un tipo de matriz, y que expandir un tipo de matriz en tiempo de ejecución no es tan rápido como lo es con un TList.

3. Usa genéricos. Colecciones TList con tus clases. Esto le permite evitar la subclasificación de TList o TObjectList cada vez que quiera utilizar una lista con una clase diferente.

Un ejemplo de código que muestra matrices dinámicas:

 TMyRec = record
    ///
 end;

 TMyRecArray = array of TMyRec;

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

Ahora para obtener información general sobre por qué TList no es fácil de usar con los tipos de registros:

TList es más adecuado para su uso con tipos de clase, porque una variable de tipo ''TMyClass'', donde ''tipo TMyClass = clase .... fin;'' puede "referirse a" fácilmente como un valor de puntero, que es lo que TList tiene.

Las variables de tipo Record son Value-Types en Delphi, mientras que los valores de clase son implícitamente valores de referencia. Puede pensar en valores de referencia por referencia como punteros sigilosos. No tiene que desreferenciarlos para obtener sus contenidos, pero cuando los agrega a un TList, en realidad solo está agregando un puntero al TList, no haciendo una copia ni asignando ninguna memoria nueva.

La respuesta de Remy te muestra literalmente cómo hacer exactamente lo que quieres, y solo escribo mi respuesta porque quiero advertirte sobre los detalles de lo que estás preguntando, y sugiero que consideres alternativas también.

Answer 4

Puede usar TList para eso, por ejemplo:

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

Puedes echar un vistazo a nuestra envoltura TDynArray . Se define en una unidad de código abierto, que funciona desde Delphi 6 hasta XE.

Con TDynArray , puede acceder a cualquier matriz dinámica (como TIntegerDynArray = array of integer o TRecordDynArray = array of TMyRecord ) usando propiedades y métodos tipo TList , por ejemplo Count, Add, Insert, Delete, Clear, IndexOf, Find, Sort y algunos nuevos métodos como LoadFromStream, SaveToStream, LoadFrom y SaveTo que permiten la serialización binaria rápida de cualquier matriz dinámica, incluso que contenga cadenas o registros; un método CreateOrderedIndex también está disponible para crear índices individuales de acuerdo con el contenido de la matriz dinámica. También puede serializar el contenido de la matriz en JSON, si lo desea. Slice, Reverse métodos Slice, Reverse o Copy también están disponibles.

Manejará una matriz dinámica de registros, e incluso registros dentro de registros, con cadenas u otras matrices dinámicas dentro.

Al usar una variable de Count externa, puede acelerar mucho la adición de elementos en la matriz dinámica referida.

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

También hay una clase TDynArrayHashed , que permite el hashing interno de un contenido de matriz dinámico. Es muy rápido y es capaz de cifrar cualquier tipo de datos (hay hashers estándar para cadenas, pero puede suministrar los suyos, incluso la función hash se puede personalizar).

Tenga en cuenta que TDynArray y TDynArrayHashed son solo envoltorios alrededor de una variable de matriz dinámica existente. Por lo tanto, puede inicializar un wrapper TDynArray cuando lo necesite, para acceder de manera más eficiente a cualquier matriz dinámica nativa de Delphi.

Answer 6

Todo depende del tipo de datos que desee almacenar.

Puede considerar usar TCollection y TCollectionItem .

Aquí está el código ( editado ) de una unidad de trabajo, en el que utilicé TCollection para leer una lista de definiciones de informes de una carpeta. Cada informe consistía en una especie de plantilla y una declaración SQL que debía almacenarse junto con un nombre de archivo.

Como está editado y usa algunas de mis unidades (TedlFolderRtns lee archivos en una lista interna, por nombrar solo uno), el ejemplo es lo suficientemente simple como para ser útil. Con unos pocos reemplaza todo, puedes adaptarte a tus necesidades.

Busque TCollection en la ayuda, puede hacer mucho con eso. Y mantiene el manejo de su código muy bien agrupado en una estructura de clase.

  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.

Usar como :

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