Objet ou Packed record ?Résolu

Question

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

WhiteHippo · Accepted Answer

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. 
<hr />"L'imagination est plus importante que le savoir." Albert Einstein

florenth · Answer

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.nethttp://te%3C/body

Toya78 · Answer

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...

florenth · Answer

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.nethttp://te%3C/body

Toya78 · Answer

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 :)

f0xi · Answer

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

http://deefaze.gnomz.com

Toya78 · Answer

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 ;)

florenth · Answer

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.nethttp://te%3C/body

f0xi · Answer

oui florenth on peu faire les deux.
heritage ou composition ... tout depend de ce qu'on veux en faire aprés.
mais le principe reste le meme, puisque dans le cas de l'heritage on travailera avec les inherited a gogo et qu'avec la compo on travaillera avec les methodes d'un objet fList (TList).

les deux methodes sont bonnes bien que la composition est plus "facile" et propre.

ici l'avantage de l'heritage est de pouvoir acceder directement a TList (Get, Put, Items, etc)

function GetItem(index: integer) : TFileItem;
begin
  result := pFileItem(inherited Get(index))^;
end;

la ou en composition on devrait faire :

function GetItem(index: integer) : TFileItem;
var ptr: pointer;
begin
  ptr := fList.Items[index];
  result := pFileItem(ptr)^;
end;

et surtout aussi, l'heritage permet d'acceder a la methode protected TList.Notify qui permet de regler les cas d'actions sur les items (add, delete, extract etc)

donc voila, pour ma part je prefere l'heritage puis la composition comme pour TStrings, TStringsList puis composition TListBox, TMemo, TComboBox etc.
ça reviens un peu commme quand on crée une collection :
CollectionItem > Collection > Composant/Manager

bon par contre, l'heritage specialise la nouvelle classe qui ne sera utilisable que pour cela, la ou la composition permet d'utiliser la TList comme bon nous semble (melange de type (risqué!)).
donc cela prouve bien que les deux solutions sont bonnes, cela depend surtout de l'utilisation qu'on vas en faire. juste que l'heritage demande une attention plus poussée pour eviter les bugs.

<hr size="2" width="100%" />
http://deefaze.gnomz.com

florenth · Answer

Merci de ton éclaircissement. En effet, si on veut consacrer la classe pour sa fonction de liste, alors autant hériter. 
Mais faut faire gaffe en effet, la composition limite de ce côté les bugs.
Mais elle permet aussi d'éviter d'exposer certaines méthodes dérivées de TList qu'il vaut mieux dans certains cas laisser de côté (comme les cas où Add doit faire quelque chose de précis en plus de FList.Add, il faut empêcher l'utilisation de Insert).

PS: on peut aussi faire en une ligne :

function GetItem(index: integer) : TFileItem;
begin
  Result := pFileItem(fList[index])^;
end;

PS2 (pas la console): dommage qu'il n'y ai pas de moyen "simple" de faire des templates (à la c++)... pour les listes au moins ça serait utile.

Bonne prog'

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.nethttp://te%3C/body

salim07360 · Answer

slt , j essayé  , mais ça marche pas tjrs ! j c pas pkoi , mais apparament c pas la bonne solution ! et en plus sous delphi5 , c pas kif kif , sous delphi7 , c plus rapide , et plus facile !

/dev/null · Answer

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

Objet ou Packed record ?

12 réponses

Votre réponse

Discussions similaires