TObjectList class differente

Version imprimable

Bonjour, je souhaiterais avoir une liste avec des modes différents de sauvegarde, chaque mode ayant sa propre classe.
J'ai commencé comme ci-dessous, Je viens demander vos précieux conseils, est-ce la bonne façon de procéder ?
au départ je testais avec ClassName = 'TBackupModeLocal'

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
Unit uBackupMode;
 
Interface
 
Uses
  Classes, Generics.Collections;
 
Type
  TMode = (mLocal, mFTP);
 
  TBackupMode = Class
  Public
    Mode: TMode;
  End;
 
  TBackupModeLocal = Class(TBackupMode)
    Constructor Create;
  End;
 
  TBackupModeFTP = Class(TBackupMode)
    Constructor Create;
  End;
 
  TListBackupMode = Class(TObjectList<TBackupMode>)
 
  End;
 
Var
  ListBackupMode: TListBackupMode;
 
Implementation
 
{ TBackupModeLocal }
 
Constructor TBackupModeLocal.Create;
Begin
  Mode := mLocal;
End;
 
{ TBackupModeFTP }
 
Constructor TBackupModeFTP.Create;
Begin
  Mode := mFTP;
End;
 
Initialization
 
ListBackupMode := TListBackupMode.Create;
 
Finalization
 
ListBackupMode.Free;
 
End.

Code:

1
2
3
4
5
6
7
 
  ListBackupMode.Add(TBackupMode(TBackupModeLocal.Create));
  If ListBackupMode.First.Mode = mLocal Then
  Begin
    // with TBackupModeLocal(ListBackupMode.First) do
    // ...
  End;

Merci d'avance.

l'opérateur is ?
Code:

1 2 3 4 5 If ListBackupMode.First is TBackupModeLocal Then Begin // with TBackupModeLocal(ListBackupMode.First) do // ... End;
Si ta Registry est fixe (ça doit être le cas vu l'énumération), une collection n'est pas un lourd surtout pourquoi créer les instances au moment de l'initialisation alors que l'on peut faire une classe registry au lieu d'une instance registry !

un bon vieux code D7 !
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 Unit uBackupMode; Interface Uses Classes; Type TMode = (mLocal, mFTP); TBackupMode = class(TObject) Public Mode: TMode; procedure Backup(); end; TBackupEngine = class(TObject) protected procedure InternalBackup(); virtual; abstract; end; TBackupEngineClass = class of TBackupEngine; Implementation // classe privée ! type TBackupModeLocal = Class(TBackupEngine) procedure InternalBackup(); override; end; TBackupModeFTP = Class(TBackupEngine) procedure InternalBackup(); override; end; const _BACKUP_CLASSES : array[TMode] of TBackupEngineClass = (TBackupModeLocal, TBackupModeFTP); { TBackupMode } procedure TBackupMode.Backup(); begin with _BACKUP_CLASSES[Mode].Create() do try InternalBackup(); finally Free(); end; end;
je ne suis pas familier des Génériques Delphi mais ceci est étrange :
Code:

1 2 3 TListBackupMode = Class(TObjectList<TBackupMode>) End;
j'aurais écrit ceci :

Code:

TListBackupMode = TObjectList<TBackupMode>;

Ci c'est juste créer une liste sans ajouter de méthode, c'est bien suffisant, en tout cas, c'est comme ça avec les templates C++

Tu ne devrais créer les instances de classe qu'à l'utilisation et la liste pourrait être statique.
Avec un héritage correct pour éviter tout transtypage.

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
Type
  TBackupMode = (bmLocal, bmFtp);
 
  TBackupClass = class of TBackup;
  TBackup = Class
  private
    procedure Backup(aFileName :TFileName); virtual; abstract;
  End;
 
  TBackupLocal = Class(TBackup)
  private
    procedure Backup(aFileName :TFileName); override;
  End;
 
  TBackupFTP = Class(TBackup)
  private
    procedure Backup(aFileName :TFileName); override;
  End;
 
const
  BackupModeList : array[TBackupMode] of TBackupClass = (TBackupLocal, TBackupFTP);
 
procedure Backup(aFileName :TFileName; aMode :TBackupMode);
 
implementation
 
{ TBackupLocal }
 
procedure TBackupLocal.Backup(aFileName :TFileName);
begin
 
end;
 
{ TBackupFTP }
 
procedure TBackupFTP.Backup(aFileName :TFileName);
begin
 
end;
 
procedure Backup(aFileName :TFileName; aMode :TBackupMode);
begin
  with BackupModeList[aMode].Create do
  try
    Backup(aFileName);
  finally
    Free;
  end;
end;

Edit: Bref comme Shai quoi :mrgreen:

Edit: sa fonctionne.

merci pour votre aide, j'ai appliquer la constante de classe dans mes méthodes.

en fait ma liste contient d'autres modes et méthodes, voilà une version un peu plus complète :

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
Unit uBackupMode;
 
Interface
 
Uses
  Classes, Generics.Collections;
 
Type
  TMode = (mLocal, mFTP);
 
  TBackupMode = Class
  Public
    Mode:                           TMode;
    Active, OnConnect, OnDiconnect: Boolean;
    Name:                           String;
    NbMax:                          integer;
    Procedure MakeSaveDB(sDBFile: String); Virtual; Abstract;
    Constructor Create;
  End;
 
  TBackupModeLocal = Class(TBackupMode)
  Public
    Directory: String;
    Procedure MakeSaveDB(sDBFile: String); Override;
    Constructor Create;
  End;
 
  TBackupModeFTP = Class(TBackupMode)
  Public
    User, Password, Host, Path: String;
    Port:                       integer;
    UseSSL:                     Boolean;
    Procedure MakeSaveDB(sDBFile: String); Override;
    Constructor Create;
  End;
 
  TBackupModeClass = Class Of TBackupMode;
 
  TListBackupMode = Class(TObjectList<TBackupMode>)
  Public
    Procedure MakeSaveDB(sDBFile: String);
    Procedure SaveToStream(ms: TMemoryStream);
    Procedure LoadFromStream(ms: TMemoryStream);
  End;
 
Var
  ListBackupMode: TListBackupMode;
 
Implementation
 
Const
  cBACKUP_CLASSES: Array [TMode] Of TBackupModeClass =
    (TBackupModeLocal, TBackupModeFTP);
 
  { TBackupMode }
 
Constructor TBackupMode.Create;
Begin
  Active      := False;
  OnConnect   := False;
  OnDiconnect := False;
  Name        := '';
  NbMax       := 0;
End;
 
{ TBackupModeLocal }
 
Constructor TBackupModeLocal.Create;
Begin
  Mode      := mLocal;
  Directory := '';
End;
 
Procedure TBackupModeLocal.MakeSaveDB(sDBFile: String);
Begin
  // -
End;
 
{ TBackupModeFTP }
 
Constructor TBackupModeFTP.Create;
Begin
  Mode     := mFTP;
  User     := '';
  Password := '';
  Host     := '';
  Path     := '';
  Port     := 0;
  UseSSL   := False;
End;
 
Procedure TBackupModeFTP.MakeSaveDB(sDBFile: String);
Begin
  // -
End;
 
{ TListBackupMode }
 
Procedure TListBackupMode.LoadFromStream(ms: TMemoryStream);
Begin
  // -
End;
 
Procedure TListBackupMode.MakeSaveDB(sDBFile: String);
Var
  I: integer;
Begin
  For I := 0 To Count - 1 Do
  Begin
    If Not Items[I].Active Then
      Continue;
 
     (Items[I] as cBACKUP_CLASSES[Items[I].Mode]).MakeSaveDB(sDBFile);
  End;
End;
 
Procedure TListBackupMode.SaveToStream(ms: TMemoryStream);
Begin
  // -
End;
 
Initialization
 
ListBackupMode := TListBackupMode.Create;
 
Finalization
 
ListBackupMode.Free;
 
End.

c'est plus clair comme sa merci à vous.

Code:

1
2
3
4
5
6
7
8
Procedure TListBackupMode.MakeSaveDB(sDBFile: String);
Var
  I: integer;
Begin
  For I := 0 To Count - 1 Do
    If Items[I].Active Then
      Items[I].MakeSaveDB(sDBFile);
End;

ou avec array: (TListBackupMode comme classe TObject non-instancée et des méthodes de classe.)

Code:

1
2
3
4
5
6
7
8
9
10
11
class procedure TListBackupMode.MakeSaveDB(sDBFile: String);
var
  Mode :TBackupMode;
Begin
  for Mode := Low(TBackupMode) to High(TBackupMode) do
    with BackupModeList[Mode].Create do
    begin
      Backup(aFileName);
      Free;
    end;
End;

...mais pas les deux ;)

Sinon, tes constructeurs, tu pourrais les économiser du code dessus
Tout est à zéro dans un TObject, donc les chaines à '', boolean à false, integer à 0 ...

C'est confus, tu as à la fois un array et TObjectList ?
Tu as laissé les Add pour ajouter des objets ?

Avec le polymorphisme et une générique, tu ne devrais pas avoir à utiliser as ,
ça c'était à l'époque de D7 où l'on devait typer le TObject en quelque chose (par exemple TBackupMode)

là, cela peut se faire tout seul, le Items[I] du TObjectList<> est déjà un TBackupMode et donc il va appeler la bonne méthode MakeSaveDB surchargée
Code:

1 2 3 4 5 6 7 8 Procedure TListBackupMode.MakeSaveDB(sDBFile: String); Var I: integer; Begin For I := 0 To Count - 1 Do If Items[I].Active Then Items[I].MakeSaveDB(sDBFile); // Fais confiance au virtual ! End;
Edit: Bref comme AndNotOr quoi ! :mouarf: Chacun son tour

11/05/2012, 17h40
ouiouioui

Merci pour vos précieux conseil, j'ai corrigé.
Effectivement le cast ne sert à rien, j’apprends tous les jours grâce à vous:hola: