Record ou Object ?

Bonjour,

J'ai besoin de manipuler des données simples (nom, adresses, numéro de téléphone) pour une application de répertoire.

Jusqu'à présent, je manipulais une liste de chaines, une par contact, mais la manipulation est un peu fastidieuse.

Je me tourne donc vers les Records ou les Objets.

Quelle seraient les avatanges/inconvénients à utiliser chacun de ces types de données ?

Merci,
Illioc

plusieurs solutions :

TCollection et TCollectionItem

Class perso et TList/TObjectList dérivé

Record avancé et Generics.Defaults.TList<[record]>

ou encore en utilisant un petit SGBD comme SQLite3 (en dll).

ou encore avec XMLDOC.

Une base de données sera un disproportionnée pour mon usage (max une centaine de contacts)..

Je vais préciser ma demande qui est un peu vague.

J'hésite entre utiliser des Records et des Objets...
- Je peux créer une structure de données simple avec les Records comme les Objets, donc égalité.
- Les objets permettent d'avoir leur propres méthodes, mais ce n'est pas bloquant en soi car il est toujours possible d'avoir des procédures dédiées pour gérer les Records.

Par contre, ce qui est déterminant:
- Peut-on trier des Records / Objets facilement ?
- Peut-on rechercher des Records / Objets facilement ?
- Qu'est ce qui est le plus facile à manipuler, à lire et écrire dans un fichier ?

Merci,
Illioc

que ce soit record ou tobject c'est pareil, tout aussi contraignant pour le tris.

il faut ecrire une fonction de tri qu'on pourra passer a TList par exemple.

regarde cette source basé sur TPersistent, TComponent et TList :

tu peux egalement regarder la FAQ au niveai Tri quickSort, tri a bulle, tri part insertion etc.

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
{ ScoreUtils
 
  by Deefaze [f0xi - 2009]
 
  1.0.0.0 : 07/19/2009
 
 
 - Scores INI file struc :
 
     section [scores]
       count : number of players scores (integer)
 
     section [(0..n)]
       playerName    : player name (string)
       playerScoreLo : low part of player score (integer)
       playerScoreHi : high part of player score (integer)
 
     exemple :
      [scores]
      count=2
      [0]
      playerName=Titi
      playerScoreLo=100
      playerScoreHi=0
      [1]
       playerName=Taz
      playerScoreLo=98
      playerScoreHi=0
 
 - Score file reading/writing :
     You do not need TIniFile objet for read or write scores file,
     use TPlayerScores.LoadFromFile or TPlayerScores.SaveToFile methods.
     Note : call SaveToFile after adding or deleting operation.
 
 - Score sorting :
     TPlayerScores sort automaticaly score at High to Low order,
     score at index 0 is the highest score, score at index=count-1 is the lowest score.
 
 - TPlayerScores instance :
     You do not need create TPlayerScores object, use ScoreUtils.Scores or ScoreUtils.PlayerScores
     variables. PlayerScores is an alias of Scores variable.
 
 - Adding score :
     Use TPlayerScores.Add methods. Add is an overloaded method :
       function Add: TPlayerScore
         Create, Add and return an empty TPlayerScore object
 
       function Add(const PlayerName: string; const PlayerScore: Int64): integer;
         Create and Add TPlayerScore objet with PlayerName and PlayerScore arguments, and
         return the index of object. Warning : after EndUpdate, index of item
         can be changed, use TPlayerScore.Index property for know the current index of
         item.
 
       function Add(PlayerScore: TPlayerScore): integer;
         Add existing TPlayerScore object, and return the index of object.
         Warning : after EndUpdate, index of item can be changed, use
         TPlayerScore.Index property for know the current index of item.
 
  - Deleting score :
      Use TPayerScores.Delete methods. Delete is an overloaded method :
        procedure Delete(const index: integer);
          Deleting item at specified index.
 
        procedure Delete(const PlayerName: string);
          Deleting all score of specified Player.
 
      Use Clear method to delete all scores.
 
}
unit ScoreUtils;
 
interface
 
uses
  Windows, SysUtils, Classes, Controls;
 
type
  TPlayerScore  = class;
  TPlayerScores = class;
 
  TPlayerScore = class(TPersistent)
  private
    fOwner       : TPlayerScores;
    fPlayerName  : string;
    fPlayerScore : int64;
    procedure SetPlayerName(const Value: string);
    procedure SetPlayerScore(const Value: int64);
    function GetIndex: integer;
  protected
    procedure Change; virtual;
  published
    property Index       : integer read GetIndex;
    property PlayerName  : string read fPlayerName  write SetPlayerName;
    property PlayerScore : int64  read fPlayerScore write SetPlayerScore default 0;
  public
    constructor Create; virtual;
    constructor CreateAdd(AOwner : TPlayerScores); virtual;
    procedure Assign(Source : TPersistent); override;
  end;
 
  TPlayerScores = class(TComponent)
  private
    fList        : TList;
    fUpdateCount : integer;
    fOnChange    : TNotifyEvent;
    fOnAfterSave: TNotifyEvent;
    fOnBeforeLoad: TNotifyEvent;
    fOnBeforeSave: TNotifyEvent;
    fOnAfterLoad: TNotifyEvent;
    function GetItem(Index: Integer): TPlayerScore;
    procedure SetItem(Index: Integer; const Value: TPlayerScore);
 
  protected
    procedure Change; virtual;
 
  public
    property Items[Index: Integer]: TPlayerScore read GetItem write SetItem; default;
 
    function Count: integer;
 
    function BeginUpdate: integer;
    function EndUpdate: integer;
 
    function Add: TPlayerScore; overload;
    function Add(PlayerScore : TPlayerScore): integer; overload;
    function Add(const PlayerName: string; const PlayerScore: int64): integer; overload;
    function IndexOf(Item: TPlayerScore): Integer;
    procedure Delete(const Index: integer); overload;
    procedure Delete(const PlayerName: string); overload;
    procedure Sort;
    procedure Clear;
 
    procedure SaveToFile(const FileName: string);
    procedure LoadFromFile(const FileName: string);
 
  public
    property OnChange     : TNotifyEvent read fOnChange     write fOnChange;
    property OnBeforeLoad : TNotifyEvent read fOnBeforeLoad write fOnBeforeLoad;
    property OnAfterLoad  : TNotifyEvent read fOnAfterLoad  write fOnAfterLoad;
    property OnBeforeSave : TNotifyEvent read fOnBeforeSave write fOnBeforeSave;
    property OnAfterSave  : TNotifyEvent read fOnAfterSave  write fOnAfterSave;
 
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;
 
var
  Scores, PlayerScores : TPlayerScores;
 
type
  bits64rec = record
    case integer of
      0: (i64 : int64);
      1: (i8  : array[0..7] of shortint);
      2: (i16 : array[0..3] of smallint);
      3: (i32 : array[0..1] of longint);
 
      4: (ui64 : UInt64);
      5: (ui8  : array[0..7] of byte);
      6: (ui16 : array[0..3] of word);
      7: (ui32 : array[0..1] of longword);
 
      8: (fl64 : double);
      9: (fl32 : array[0..1] of single);
  end;
 
implementation
 
uses IniFiles;
 
{ TPlayerScore }
 
constructor TPlayerScore.Create;
begin
  inherited Create;
  fOwner := nil;
  fPlayerName  := '';
  fPlayerScore := 0;
end;
 
constructor TPlayerScore.CreateAdd(AOwner: TPlayerScores);
begin
  Create;
  fOwner := AOwner;
  if Assigned(AOwner) then
    AOwner.Add(Self);
end;
 
function TPlayerScore.GetIndex: integer;
begin
  if assigned(fOwner) then
    result := fOwner.IndexOf(Self)
  else
    result := -1;
end;
 
procedure TPlayerScore.Change;
begin
  if Assigned(fOwner) then
    fOwner.Change;
end;
 
procedure TPlayerScore.Assign(Source: TPersistent);
begin
  if source is TPlayerScore then
    with TPlayerScore(Source) do
    begin
      Self.fPlayerName := fPlayerName;
      Self.fPlayerScore:= fPlayerScore;
    end
  else
    inherited Assign(source);
end;
 
procedure TPlayerScore.SetPlayerName(const Value: string);
begin
  if value <> fPlayerName then
    fPlayerName := Value;
end;
 
procedure TPlayerScore.SetPlayerScore(const Value: int64);
begin
  if value <> fPlayerScore then
    fPlayerScore := Value;
end;
 
 
{ TPlayerScoreList }
 
function PlayerScoreItemCompare(item1, item2: pointer): integer;
var P1, P2: int64;
begin
  P1 := TPlayerScore(item1).fPlayerScore;
  P2 := TPlayerScore(item2).fPlayerScore;
 
  if P1 > P2 then
    result := -1
  else
  if P1 < P2 then
    result := 1
  else
    result := 0;
end;
 
constructor TPlayerScores.Create(AOwner: TComponent);
begin
  inherited;
  fList := TList.Create;
end;
 
destructor TPlayerScores.Destroy;
var N : integer;
begin
  for N := 0 to fList.Count-1 do
    TPlayerScore(fList.Items[N]).Free;
 
  fList.Clear;
  fList.Free;
  inherited;
end;
 
procedure TPlayerScores.Clear;
var N : integer;
begin
  for N := 0 to fList.Count-1 do
    TPlayerScore(fList.Items[N]).Free;
 
  fList.Clear;
end;
 
function TPlayerScores.Add(PlayerScore: TPlayerScore): integer;
begin
  fList.Add(pointer(PlayerScore));
  if fUpdateCount = 0 then
    Change;
  result := PlayerScore.Index;
end;
 
function TPlayerScores.Add: TPlayerScore;
begin
  result := TPlayerScore.CreateAdd(Self);
  if fUpdateCount = 0 then
    Change;
end;
 
function TPlayerScores.Add(const PlayerName: string; const PlayerScore: int64): integer;
var PS : TPlayerScore;
begin
  PS := TPlayerScore.CreateAdd(Self);
  PS.fPlayerName  := PlayerName;
  PS.fPlayerScore := PlayerScore;
  if fUpdateCount = 0 then
    Change;
  result := PS.Index;
end;
 
function TPlayerScores.BeginUpdate: integer;
begin
  inc(fUpdateCount);
  result := fUpdateCount;
end;
 
procedure TPlayerScores.Change;
begin
  if fUpdateCount <> 0 then
    exit;
 
  fList.Sort(@PlayerScoreItemCompare);
 
  if Assigned(fOnChange) then
    fOnChange(Self);
end;
 
function TPlayerScores.Count: integer;
begin
  result := fList.Count;
end;
 
procedure TPlayerScores.Delete(const Index: integer);
begin
  TPlayerScore(fList.Items[index]).Free;
  fList.Delete(index);
end;
 
procedure TPlayerScores.Delete(const PlayerName: string);
var N : integer;
begin
  for N := fList.Count-1 downto 0 do
    if TPlayerScore(fList.Items[N]).fPlayerName =  PlayerName then
    begin
      TPlayerScore(fList.Items[N]).Free;
      fList.Delete(N);
    end;
end;
 
function TPlayerScores.EndUpdate: integer;
begin
  dec(fUpdateCount);
  result := fUpdateCount;
  if fUpdateCount = 0 then
    Change;
end;
 
function TPlayerScores.GetItem(Index: Integer): TPlayerScore;
begin
  result := TPlayerScore(fList.Items[index]);
end;
 
function TPlayerScores.IndexOf(Item: TPlayerScore): Integer;
begin
  result := fList.IndexOf(pointer(Item));
end;
 
procedure TPlayerScores.LoadFromFile(const FileName: string);
var N,C : integer;
    SEC,PN : string;
    PS : int64;
begin
  with TIniFile.Create(FileName) do
  try
    if Assigned(fOnBeforeLoad) then
      fOnBeforeLoad(self);
 
    BeginUpdate;
    try
      C := ReadInteger('scores', 'count', 0);
      for N := 0 to C-1 do
      begin
        SEC := IntToStr(N);
        PN := ReadString(SEC, 'playerName', '---');
        int64rec(PS).Lo := ReadInteger(SEC, 'playerScoreLo', 0);
        int64rec(PS).Hi := ReadInteger(SEC, 'playerScoreHi', 0);
        Add(PN, PS);
      end;
    finally
      EndUpdate;
    end;
 
    if Assigned(fOnAfterLoad) then
      fOnAfterLoad(Self);
  finally
    Free;
  end;
end;
 
procedure TPlayerScores.SaveToFile(const FileName: string);
var N : integer;
    SEC : string;
    PS  : TPlayerScore;
begin
  with TIniFile.Create(FileName) do
  try
    if assigned(fOnBeforeSave) then
      fOnBeforeSave(self);
 
    WriteInteger('scores', 'count', fList.Count);
    for N := 0 to fList.Count-1 do
    begin
      SEC := IntToStr(N);
      PS  := TPlayerScore(fList.Items[N]);
      WriteString(SEC, 'playerName', PS.fPlayerName);
      WriteInteger(SEC, 'playerScoreLo', int64rec(PS.fPlayerScore).Lo);
      WriteInteger(SEC, 'playerScoreHi', int64rec(PS.fPlayerScore).Hi);
    end;
 
    if Assigned(fOnAfterSave) then
      fOnAfterSave(Self);
  finally
    Free;
  end;
end;
 
procedure TPlayerScores.SetItem(Index: Integer; const Value: TPlayerScore);
begin
  TPlayerScore(fList.Items[index]).Assign(Value);
end;
 
procedure TPlayerScores.Sort;
begin
  fList.Sort(@PlayerScoreItemCompare);
end;
 
initialization
  Scores := TPlayerScores.Create(nil);
  PlayerScores := Scores;
 
finalization
  Scores.Free;
 
end.

pour trier,rechercher utiliser un TList
Voici une class ,pour les autres unités se sont disponible ici

Code:

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
42
43
44
45
46
47
48
unit ClassesChaine;
 
interface
 
uses
  SysUtils,Classes,Userialize;
 const
    AGTAG        = 01;
    AGCHILDS     = 02;
 
type
 
  TAgFields=class(TStrFields)
  public
    property NomOpr  :string index 0 read Get_Str write Set_Str;
    property Champ1  :string index 1 read Get_Str write Set_Str;
    property Champ2  :string index 2 read Get_Str write Set_Str;
    property Champ3  :string index 3 read Get_Str write Set_Str;
    property Champ4  :string index 4 read Get_Str write Set_Str;
  // property Champ4  :integer index 4 read Get_int write Set_int;
  end;
 
  TAgRessource=class(TFieldsList)
  private
     function Get_Item(idx:integer):TAgFields;
  public
    constructor Create();
    property Items[index:integer]:TAgFields read Get_Item; default;
  end;
 
implementation
 
{================================================================
                           TAgRessource                         +
================================================================}
constructor TAgRessource.Create();
begin
    inherited Create(AGTAG,AGCHILDS);
    DefClass := TAgFields;
    FieldsCount:=5;
end;
 
function TAgRessource.Get_Item(idx:integer):TAgFields;
begin
   result:=TAgFields(Get(idx));
end;
 
end.

Merci pour vos réponses, je vais étudier tout ça et voir si je m'en sors avec les Objets. :)

Illioc

Citation:

Envoyé par illioc

Merci pour vos réponses, je vais étudier tout ça et voir si je m'en sors avec les Objets. :)

Illioc

la différence la plus notable entre les deux (dans ton cas) est que chaque objet doit être créé individuellement alors que tu peux gérer un array of record avec une seule allocation (SetLength)

maintenant, si tu veux gérer facilement l'ajout suppression, trie de ta liste de record, une liste d'objets sera plus simple...encore que ça dépend aussi de la structure de ton record...s'il ne contient que des données statiques (ShortString au lieu de String par exemple), tu peux assez facilement gérer cela...faire une sauvegarde dans un fichier de tout ton tableau de record en une opération, etc...