Discussion :

[ed973]

Bonjour

Sujet mainte fois débattu j'imagine.
J'ai un composant que je streame (sauvegarde comme file) et qui possède des Type Record comme propriété placé en published. Sauf que les type Record ne sont pas streamés.
Une suggestion, à part éclater chaque ligne de mes record en autant de propriété de type simple ?

Merci

[Paul TOTH]

1) DefineBinaryProperty
2) RegisterPropertyEditor
3) remplacer le record par un dérivé TPersistent
4) publier les différents champs du record comme des propriétés

[ed973]

OK pour le 4, c'est ce que je fais habituellement
pour le 3, plus élégant mais faut instancier/détruire chaque objet, ce que nous épargne justement les record...
1 et 2, un peu trop élaboré pour ce que j'ai à faire

Merci pour ta réponse

[Caribensila]

Salut,

Et avec WriteComponentResFile() et ReadComponentResFile() ?

[ed973]

En fait, je me demandais juste si, depuis le temps, quelqu'un avait pondu une procédure qui écrive et lise un type record dans un stream afin de rendre à peu prés transparente la persistence des Record.

Sinon, je n'ai pas de problème à modifier mon code pour obtenir cette persistence, je trouve juste dommage que Delphi ne soit pas trés performant sur cet aspect et oblige à chaque fois à réinventer la roue.

[Caribensila]

Un Record c'est un Pointeur. Il faudrait donc automatiser ce que tu fais à la main. Ce n'est pas impossible...

Mais dans ton cas, le plus simple serait d'utiliser une chaîne pour écrire ton compo dans le TStream.
Voici un exemple avec un TPanel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
function CompoVersChaine(Compo : TComponent):string;
{On utilise la gestion de flux de composant intégré pour convertir un composant en une chaîne.}
  var
      MemStrm : TMemoryStream;
      StrStrm : TStringStream;
      S       : String;
  begin
  MemStrm := TMemoryStream.Create;
  try
    StrStrm := TStringStream.Create(S);
 
    try
      MemStrm.WriteComponent(Compo);//Ecrit le Compo dans le flux TMemoryStream.
      MemStrm.Seek(0,soFromBeginning);//Se place au début du flux MemStrm.
      ObjectBinaryToText(MemStrm,StrStrm);//Convertit l'objet contenu ds MemStream en une version littérale simple et le place ds StrStrm.
      StrStrm.Seek(0,soFromBeginning);//Se place au début du flux StrStrm.
      Result := StrStrm.DataString;//On accéde au texte du flux.
    finally StrStrm.Free;  end;
 
  finally MemStrm.Free;  end;
end;
 
 
procedure ChaineVersCompo(Chaine : string; Compo : TComponent);
{On utilise la gestion de flux de composant intégré pour convertir une chaîne en un composant.}
  var
      MemStrm : TMemoryStream;
      StrStrm : TStringStream;
  begin
  StrStrm := TStringStream.Create(Chaine);
  try
    MemStrm := TMemoryStream.Create;
 
    try
      ObjectTextToBinary(StrStrm,MemStrm);
      MemStrm.Seek(0,soFromBeginning);
      MemStrm.ReadComponent(Compo);
    finally MemStrm.Free; end;
 
  finally StrStrm.Free; end;
end;

Ecriture et lecture d'un Compo dans le flux (ici le TPanel Pnl_Conteneur).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
...
{Ecriture du compo Pnl_Conteneur.
 NB: il sera écrit avec les compos dont il est le owner.
 L'astuce est de convertir le compo en chaîne et d'écrire cette chaîne...}
Chaine := CompoVersChaine(Pnl_Conteneur);//Conversion...
Taille := length(Chaine);//...puis, comme une chaîne longue.
FileStrm.WriteBuffer(Taille,SizeOf(Taille));
FileStrm.WriteBuffer(Chaine[1],Taille);
...
{Lecture du compo Pnl_Conteneur.
 NB: il est lu comme une chaîne,
 puis cette chaîne sera convertie en compo.}
FileStrm.ReadBuffer(Taille,SizeOf(Integer));
SetLength(Chaine,Taille);
FileStrm.ReadBuffer(Chaine[1],Taille);
ChaineVersCompo(Chaine,Pnl_Conteneur);

[ed973]

En fait, j'ai déjà fait ça (transformer les données en chaine et inversement). Mais ce sont des cas particulier sur un type connu. C'est l'aspect générique qui m'interesserait sur un type quelconque (mais ce n'est peut-être pas possible avec des record, d'où la nécessité de passer par TPersistent)

Ce n'est pas trés important, ça me prend pour l'instant dix minutes de codage supplémentaire, donc sans incidence pour moi.

OK, je vais regarder ton code (mais pas tout de suite).

Merci pour l'exemple

[Paul TOTH]

dans les dernières versions de Delphi, les RTTI sont disponibles à tous les niveaux...il doit être possible de génériser ça

[ShaiLeTroll]

il me semble que SJRD l'a déjà fait : Enregistrement de record non finalisé : ScSerializer avec les anciennes RTTI via TypInfo.GetTypeData encapsulé dans ScTypInfo en s'inspirant de Finalize \ System._FinalizeRecord qui arrive a nettoyer correctement un struct contenant un array dynamique !

Sinon, un record avec des types simples comme ShortString, integer, array[0..1] of integer, ... peut être sérialisez brutalement
dès que cela contient dyn array ou string, cela se complique d'où l'API de SJRD

[ed973]

Oui, j'ai vu que dans les dernières versions, les recors avaient pas mal évolué. mais là, je développe toujours avec mon antique D6.
En tout cas merci à tous pour votre flots de réponses pertinentes. Ce forum est toujours un plaisir pour apprendre.