Bonjour à tous,

Travaillant sur un gros projet perso, je me suis soudain rendu compte que j'avais un choix à faire.

Voici la situation : mon programme doit lire de nombreuses informations dans un très gros fichier (informations structurées en article). J'ai 2 solutions :

Solution 1 :
type
   TInfo = packed record
      entier : Integer;
      mot : Word;
      mot2 : Word;
   end;

   TGroupe = class
      private
         _infos : array of TInfos;
      public
         //...
   end;

Dans cet exemple, ce qui est intéressant c'est le packed record car il permet de lire plus rapidement le fichier avec un simple mon_file_stream.Read(mon_info, SizeOf(mon_info)). De plus, pas besoin de se préoccuper de la destruction des TInfo.

 

Toutefois, je suis tenté de passer ce packed record en classe (qui n'aurait que des attributs privés et des propriétés pour y accéder), afin de pouvoir les gérer en tant qu'objets et ainsi utiliser un TObjectList plutôt qu'un tableau dynamique.

Solution 2 :
type
   TInfo = class
      private
         _entier : Integer;
         _mot : Word;
         _mot2 : Word;
      public
         //...
      property
         //accès aux attribus privés
   end;

   TGroupe = class
      private
         _infos : TObjectList;   //stocke les TInfo
      public
         ...
   end;

Ici, l'avantage c'est que la gestion des TInfo sera plus agréable grâce au TObjectList.

Pour résumer :
soit : des packed record stockés dans un tableau (plus rapide pour la lecture du fichier et évite de gérer les destructions d'objets)
soit : des objets stockés dans un TObjectList (plus agréable pour gérer les objets)

J'hésite vraiment entre les deux... à moins qu'il existe une classe TPackedRecordList lol

Quel est votre avis ?

Merci d'avance

Salut !

Tout dépend de ce que tu comptes faire avec ta liste: si c'est juste ajout, lecture, suppression totale, tu peux garder des record, c'est très bien comme cela.
Par contre, si tu as besoin de plus de souplesse (ré ordonnancement des record) ou bien d'avoir des getter/setters spéciaux ou encore si ta classe TGroupe se préoccupe un peu trop de ce que font des TInfo (ce qui ne devrait jamais être le cas) alors il est peut être judicieux de passer à une classe.

Si c'est le chargement/sauvegarde dans un flux qui te pose problème, saches que ce n'est vraiment pas plus compliqué avec des classes. Il faut juste penser à créer deux méthodes dans TInfo (LoadFromStream() et SaveToStream()) qui s'occuperont du tout.

Voila, j'ai essayé d'être concis dans ma réponse.

A+
Flo

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.net [ Lien ]

Réponse acceptée !

Bonjour

Allez de quoi te donner un peu plus de matière pour ta reflexion. Tu gardes la première solution, mais tu crées en plus une classe de manipulation de tes données :

type
  PInfo = ^TInfo
  TInfo = packed record
     entier : Integer;
     mot : Word;
     mot2 : Word;
   end;

 TClassInfo = class
 private
   FInfo : PInfo ; 
 public
   constructor Create( AInfo : PInfo ) ;
   property ...
 end;

Tu utilises alors cette classe juste pour faciliter l'accès à tes données lorsque tu as besoin de les manipuler.

var
  UneInfo : TClassInfo ;
begin
  UneInfo := TClassInfo .Create( @_infos[1] ) ;
  try
    // Manipulation des données
    UneInfo.entier := UneInfo.entier + 10 ;
  finally
    UneInfo.Free;
  end ;
end ;

P.S. Ne connaissant ni ton niveau, ni ton avancement dans ton projet, je ne peux que te proposer une solution, parmi beaucoup d'autres, en fonction des éléments que tu as fourni.

Cordialement.

---

"L'imagination est plus importante que le savoir." Albert Einstein

Merci Florenth de t'intéresser au sujet.
En effet ce n'est pas plus compliqué de gérer ces chargements/enregistrements dans les flux. Mon appli est déjà en "objets" d'ailleurs :). Le seul soucis qui me préoccupait était les performances de lecture (le traitement est assez lourd : il y a beaucoup d'articles et le fichier pèse 130Mo :p). En effet, je pensais que c'était plus rapide de faire :

mon_file_stream.Read(mon_packed_record, SizeOf(mon_packed_record));       //Affecte en une seule lecture les 3 attributs du packed record

plutôt que :

mon_file_stream.Read(mon_objet.attribut1, 1);
mon_file_stream.Read(mon_objet.attribut2, 2);
mon_file_stream.Read(mon_objet.attribut3, 2);        //3 lectures nécessaires pour affecter les 3 attributs


Toutefois je viens de retester les temps d'exécution, et il se trouve que les 2 se valent (je précise que dans mon projet, il y a beaucoup plus d'attributs). Pourtant j'ai toujours lu et entendu dire que les lectures prenaient beaucoup de temps... Je m'y perds...

Réponse acceptée !
J'aime bien ta solution WhiteHippo, entre les deux autres en fait (mi-classe, mi-record).
Sinon, au sujet de la taille des données à charger: si ton fichier fait 130Mo, cela signifie que le charger en entier te prendra 130Mo minimum en mémoire (en réalité, plus que cela). Je te conseille alors de passer par un TObjectList qui à l'avantage d'être une liste de pointeurs, ce qui fait que les 130Mo ne devront pas forcément être contigus comme ce serait le cas pour un array of record.

Par contre, tu risques de prendre quelques kilo-octets de plus en mémoire. Mais sur 130Mo, c'est négligeable.

Pour ce qui est de la vitesse de lecture, saches que la classe TFileStream est très optimisée (en fait, pas vraiment, c'est Windows et ses fonctions qui le sont) et qu'une partie du fichier est mis en cache mémoire. Ce qui fait qu'au final, il n'y a pas un accès au disque dur par Stream.Read() mais à chaque fois que tu dépasses ce buffer interne.

Saches d'ailleurs que j'ai déjà manipulé des fichiers de plusieurs gigas (pas en mémoire, c'était pour de la recherche d'informations) et que je n'ai pas eu de problèmes. Du moment que le fichier fait moins de 4Go, c'est tout bon, après, ça pose quelques problèmes (le type Integer pas assez grand, ...) mais on n'est pas encore là.

Voila, bon week-end,
Flo

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.net [ Lien ]

Alors c'est génial ! Merci Florenth pour tes précieux conseils ;) En effet la solution de WhiteHippo (que je remercie au passage) a l'air intéressante je vais me pencher là-dessus. Merci à vous deux pour votre aide. En vous souhaitant un bon week-end :)

Je t'aurais répondu comme WhiteHippo, mais je t'aurais en plus recomandé d'utilisé la projection de fihier en mémoire. Si tu trouve que les TStream sont pratique a employé va là -> http://www.delphifr.com/codes/MAPPING-FICHIER-TSTREAM_39879.aspx 

De toutes les chose que j'ai perdues...
Celle qui me manque le plus...
C'est mon esprit.

type
  TFileHeader = record
    ReservedA : int64;  { options a ajouter }
    ReservedB : int64;  { options a ajouter }
    ReservedC : int64;  { options a ajouter }
    ItemCount : integer;
  end;
  pFileHeader = ^TFileHeader;

const
  FileHeaderSize = SizeOf(TFileHeader);

type
  TFileItem = record
    value1 : integer;
    value2 : word;
    value3 : byte;
  end;
  pFileItem = ^TFileItem;

const
  FileItemSize = SizeOf(TFileItem);

type
  TMyFile = class(TList)
  private
    function GetItem(index: integer): TFileItem;
    procedure PutItem(index: integer; value: TFileItem);
  protected
    procedure Notify(Ptr: Pointer; Action: TListNotification); override;
  public
    function Add(Item: TFileItem): Integer;
    procedure Insert(Index: Integer; Item: TFileItem);
    function IndexOf(Item: TFileItem): Integer;
    property Items[Index: Integer]: TFileItem read GetItem write PutItem; default;
    function First: TFileItem;
    function Last: TFileItem;
    procedure Clear; override;
    procedure SaveToFile(const FileName: string);
    procedure LoadFromFile(const FileName: string);
    procedure SaveToStream(Stream: TStream);
    procedure LoadFromStream(Stream: TStream);
  end;


function FileItem(const V1: integer; const V2: Word; const V3: Byte): TFileItem;
begin
  result.value1 := V1;
  result.value2 := V2;
  result.value3 := V3;
end;

function FileItemStr(const Item: TFileItem): string;
begin
  result := format('< %d / %d / %d >',[Item.value1, Item.value2, Item.value3]);
end;

{ TMyFile }

procedure TMyFile.Notify(Ptr: Pointer; Action: TListNotification);
begin
  if (ptr <> nil) and (Action = lnDeleted) then
  begin
    Dispose(ptr);
    ptr := nil;
  end;
end;

function TMyFile.Add(Item: TFileItem): Integer;
var ptr : pFileItem;
begin
  new(ptr);
  ptr^ := Item;
  result := inherited Add(ptr);
end;

procedure TMyFile.Clear;
begin
  while Count > 0 do
    Delete(Count-1);
  inherited Clear;
end;

function TMyFile.First: TFileItem;
begin
  result := pFileItem(inherited First)^;
end;

function TMyFile.GetItem(index: integer): TFileItem;
begin
  result := pFileItem(inherited Get(index))^;
end;


function TMyFile.IndexOf(Item: TFileItem): Integer;
var N : integer;
    ptrA, ptrB : pFileItem;
begin
  ptrA := @Item;
  for N := 0 to Count-1 do
  begin
    ptrB := pFileItem(inherited get(N));
    if CompareMem(ptrA, ptrB, FileItemSize) then
    begin
      result := N;
      break;
    end;
  end;
end;

procedure TMyFile.Insert(Index: Integer; Item: TFileItem);
var ptr: pFileItem;
begin
  new(ptr);
  ptr^ := Item;
  inherited Insert(index, ptr);
end;

function TMyFile.Last: TFileItem;
begin
  result := pFileItem(inherited Last)^;
end;

procedure TMyFile.PutItem(index: integer; value: TFileItem);
begin
  pFileItem(inherited get(index))^ := value;
end;


procedure TMyFile.LoadFromFile(const FileName: string);
var stream: TFileStream;
begin
  Stream := TFileStream.Create(FileName, fmOpenRead);
  try
    LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TMyFile.LoadFromStream(Stream: TStream);
var
  FileHeader : TFileHeader;
  FileItem   : TFileItem;
  N          : integer;
begin
  Stream.Read(FileHeader, FileHeaderSize);
  for N := 0 to FileHeader.ItemCount-1 do
  begin
    Stream.Read(FileItem, FileItemSize);
    Add(FileItem);
  end;
end;

procedure TMyFile.SaveToFile(const FileName: string);
var Stream: TFileStream;
begin
  Stream := TFileStream.Create(FileName, fmCreate);
  try
    SaveToStream(Stream);
  finally
    Stream.Free;
  end;
end;

procedure TMyFile.SaveToStream(Stream: TStream);
var
  FileHeader : TFileHeader;
  FileItem   : TFileItem;
  N          : integer;
begin
  FileHeader.ItemCount := Count;
  Stream.Write(FileHeader, FileHeaderSize);

  for N := 0 to Count-1 do
  begin
    FileItem := Items[N];
    Stream.Write(FileItem, FileItemSize);
  end;
end;

performances :

sauvegarde de 100 000 entrées : 524 ms
chargement de 100 000 entrées : 120 ms

---

Merci /dev/null de ta source le mapping est un sujet que je ne connais pas mais je vais m'y intéresser !

Merci à toi f0xi également (j'ose espérer que tu avais ce morceau de code déjà tout fait quelque part :o) ). Je vais examiner tout ça calmement ça a l'air intéressant ;)

Non non, à mon avis, il l'a écrit en live dans la TextBox !
C'est un brave ce f0xi !

Sinon, pour lancer le débat, f0xi, ne vaudrait-il pas mieux composer plutôt que d'hériter TList ?
Si tu n'as pas besoin de toutes les fonctions (ce qui est le cas à 90%), alors ça fait moins de travail.
Certes, ici c'est TList donc on n'est pas obligé de tout surcharger (pas comme avec TObjectList sinon gare aux bugs !) alors ça m'intéresserai d'avoir ton point de vue la dessus.
Il me semble que Delphiprog parlait lui aussi de composition...

NB: pas composition, j'entends ceci:

type
  TMyFile = class(TObject)
  private
    FList: TList;
    // Accesseurs des propriétés
  public
    [...]
    procedure Add(...)
    [...]
  end;

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.net [ Lien ]