Une idée de Pattern

Bonjour,

Je ne suis pas ur que ce soit le bon forum mais comme je bosse avec Delphi je me lance.

Voila mon idée, je travaille pour mon plaisir sur différents logiciels qui gèrent des bases de données ou tout du moins des objets indentifiés par un index. Dans mon programme, je préfère utiliser des objets qu'utiliser directement des appels à la base de données. Notamment j'ai un serveur sur un pc qui transmet les données nécessaires à un client via le réseau (et les composants TCPiP d'indy). A chaque données je crée un objet qui est stocké dans une liste. Cependant lorsque mes données font références à d'autres données je suis un peu coincé.

Par exemple j'ai différentes classes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 TClasse = class(TObject) ... public property Nom : string read FNom; property Eleves[index:Integer]:TEleve read getEleve; end; TEleve=class(TObject) ... public property Nom :string read FNom; property Prenom : string read FPrenom; property Classe : TClasse read FClasse; end;
Dans ce cas là cela ne pose pas de problèmes. Je crée mes objets de type TCLasse puis mes objets de type TEleve et je vais chercher suivant les index les objets dans ma liste de classe.

Mais je peux avoir des cas plus compliqués, ou un objet fera référence à un objet (via un index) qui sera créé par la suite. Quelqu'un a-t-il une idée pour gérer ces situations ? En effet, j'essaie de réaliser une sorte de framework dans lequel je sépare bien les taches de la base des données (de type TBase) consistant à modifier les données, et à accéder à certaines données, des tâches d'enregistrement ou de chargement des données sur le disque ou via un protocole réseau. Ainsi les données enregistrées doivent arrivées à ma base (TBase) dans n'importe quel ordre.

J'espère que j'ai été suffisament clair ce que je ne penses pas :oops:

Salut,

Citation:

Envoyé par flash_math

J'espère que j'ai été suffisament clair ce que je ne penses pas

Je n'ai pas compris ce qui transite entre les postes ?
Tous les postes ont accés à la base de donnéés ?

Citation:

Mais je peux avoir des cas plus compliqués, ou un objet fera référence à un objet (via un index) qui sera créé par la suite. Quelqu'un a-t-il une idée pour gérer ces situations ?

A prioris je ne vois pas d'autre issu qu'un traitements en 2 passes. Les clés primaire et étrangéres de chaque objet devant être mémorisées dans chacun d'entre eux afin de reconstruire les liens.
Dans ce cas tes classes devront héritées non pas de TObject mais d'une classe commune gérant ces infos.
Je pense que tu dois aussi gérer les cas de deep copy (objets imbriqués sur + niveaux) ?
Bon c'est le premier truc qui me viens à l'esprit :roll:

Concernant le framework cela ressemble à ceci ?
http://www.instantobjects.org/

Merci Laurent de ta réponse.

En fait j'ai une application serveur sur un poste qui travaille sur une base MySQL (pour l'instant), et sur un deuxième poste j'ai une application cliente. Il s'agit en fait d'une application de gestion d'un Foyer Socio-Educatif. Comme j'en ai marre de me taper toute la gestion mes collègues saisissent les chèques qui correspondent à leur classe. Donc suivant le login du client, mon serveur envoie les données qui correspondent au login via le réseau. En fait le serveur récupère les données de la base, les mets en forme dans un flux xml qui est envoyé via le réseau en utilisant les composants Indy. Pour l'instant l'application cliente lis les données et crée les objets correspondant. Mais j'aimerais découplé le travail. Je souhaiterais que ce soit un plug-in qui fasse le transfert via le réseau afin de pouvoir à tout moment choisir un autre type de transfert que les composants Indy. (Je penses notamment à utiliser les possibilités de .Net).

Pour résumé, il n'y a qu'un poste qui a acces à la base mysql, et les clients demandent les infos qui leurs sont nécessaires à ce poste.

En réalité on peut se débrouiller pour créer les objets les uns à la suite des autres en choisissant l'ordre de création des types d'objets (exemple : les classes avant les élèves...) mais cela m'obligerait à connaitre la structure interne de la base ce que je veux éviter pour le plug-in de transfert.

Quant à la classe de base j'y ai pensé. L'exemple était un peu rapide :?

Pour l'instant j'ai cette structure :

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
interface
uses
  Borland.vcl.Classes,
  Borland.vcl.Contnrs,
  Borland.vcl.Variants;
 
Type
  TBaseNotify = (bnAdd,bnDelete,bnModif);
  TNotifyAddItem = procedure (Sender : TObject; item : TObject) of object;
 
  TBase = class;
 
  TInformation = class
  end;
 
  TInfoItem = class(TInformation)
  protected
    function GetName: string; virtual;
  public
    property Name: string read GetName;
  end;
 
  TInfoProperty = class(TInformation)
  protected
    function GetName: string; virtual;
    function GetValue: Variant; virtual;
  public
    property Name: string read GetName;
    property Value: Variant read GetValue;
  end;
 
  TLoadSaveBase = class
  public
    constructor Create; virtual;
    procedure Load; virtual; abstract;
    function Next: TInformation; virtual; abstract;
    procedure Reset; virtual; abstract;
  end;
 
  TBase = class
  private
    FAdded : TList;
    FDeleted : TList;
    FLoadSavePlugIn: TLoadSaveBase;
    FModificated : TList;
    FOnAddItem: TNotifyAddItem;
    FOnDeleteItem: TNotifyAddItem;
    FOnModifItem: TNotifyAddItem;
    procedure AddItemEvent(value: TObject);
    procedure DeleteItemEvent(value: TObject);
    procedure ModifyItemEvent(Value: TObject);
  protected
    procedure AddItem(value : TObject);
    procedure CreateItem(info: TInfoItem); virtual; abstract;
    procedure DeleteItem(value : TObject);
    procedure LoadProperty(item: TObject; info: TInfoProperty); virtual; abstract;
    procedure ModifyItem(value : TObject);
    procedure Notify(mess : TBaseNotify ;value:TObject);
  public
    constructor Create(plugIn: TLoadSaveBase);
    procedure LoadBase;
    property LoadSavePlugIn: TLoadSaveBase read FLoadSavePlugIn;
  published
    property OnAddItem: TNotifyAddItem read FOnAddItem write FOnAddItem;
    property OnDeleteItem: TNotifyAddItem read FOnDeleteItem write FOnDeleteItem;
    property OnModifItem: TNotifyAddItem read FOnModifItem write FOnModifItem;
  end;
 
  TBaseClass= class of TBase;
  TPlugInClass= class of TLoadSaveBase;
 
  //Fabrique de classe de l'élément
  TBaseFactory = class
 
  private
    FBaseClass: TBaseClass;
    FPlugInClass: TPlugInClass;
  public
    constructor Create(baseType: TBaseClass; plugInClass: TPlugInClass);
    function CreateBase: TBase;
  end;
 
implementation
 
constructor TBase.Create(plugIn: TLoadSaveBase);
begin
  inherited;
  FLoadSavePlugIn:=plugIn;
end;
 
{ TBase }
 
procedure TBase.AddItem(value: TObject);
begin
  FAdded.Add(value);
end;
 
procedure TBase.AddItemEvent(value: TObject);
begin
  if assigned(FOnAddItem) then
    FOnAddItem(self,value);
end;
 
procedure TBase.DeleteItem(value: TObject);
begin
  FDeleted.Add(value);
end;
 
procedure TBase.DeleteItemEvent(value: TObject);
begin
  if assigned(FOnDeleteItem) then
    FOnDeleteItem(self,value);
end;
 
procedure TBase.LoadBase;
var info:TInformation;
    item:TObject;
begin
  FLoadSavePlugIn.load;
  //Gérer peut-être le problème de chargement.
  info:=FLoadSavePlugIn.Next;
  while info<>nil do
  begin
    if info is TInfoItem then
      item:=CreateItem(TInfoItem(info))
    else
      LoadProperty(item,TInfoProperty(info));
    info:=FLoadSavePlugIn.Next;
  end;
end;
 
procedure TBase.ModifyItem(value: TObject);
begin
  FModificated.Add(value);
end;
 
procedure TBase.ModifyItemEvent(Value: TObject);
begin
  if assigned(FOnModifItem) then
    FOnModifItem(self,value);
end;
 
procedure TBase.Notify(mess: TBaseNotify; value: TObject);
begin
  case mess of
    ExpertApplications.BaseNote.UBase.bnAdd:
      begin
        FAdded.Add(value);
        AddItemEvent(value);
      end;
    ExpertApplications.BaseNote.UBase.bnDelete:
      begin
        if FAdded.IndexOf(value)<>-1 then
          FAdded.Remove(value)
        else
        begin
          if FModificated.IndexOf(value)<>-1 then
            FModificated.Remove(value);
          FDeleted.Add(value);
        end;
        DeleteItemEvent(value);
      end;
    ExpertApplications.BaseNote.UBase.bnModif:
      begin
        if FAdded.IndexOf(value)=-1 then
          FModificated.Add(value) ;
        ModifyItemEvent(value);
      end;
  end;
end;
 
constructor TLoadSaveBase.Create;
begin
  inherited;
end;
 
function TInfoItem.GetName: string;
begin
  Result := '';
end;
 
function TInfoProperty.GetName: string;
begin
  Result := '';
end;
 
function TInfoProperty.GetValue: Variant;
begin
  Result := Null;
end;
 
constructor TBaseFactory.Create(baseType: TBaseClass; plugInClass:
    TPlugInClass);
begin
  inherited;
  FBaseClass:=baseType;
  FPlugInClass:=plugInClass;
end;
 
function TBaseFactory.CreateBase: TBase;
begin
  Result := FBaseClass.Create(fplugInClass.Create);
end;
 
end.

avec :

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
   uses Borland.Vcl.classes, Borland.Vcl.Contnrs, ExpertApplications.BaseNote.Contnrs;
 
type
 
  EIndexedCollectionError = class(Exception);
 
  TIndexedCollection = class;
  TIndexedCollectionItem = class;
 
  TIndexedCollectionItemClass = class of TIndexedCollectionItem;
  TIndexedBucketProc = procedure(AInfo, AItem, AData: TObject; out AContinue: Boolean);
 
  TIndexedCollection = class(TPersistent)
  private
    FItemClass: TIndexedCollectionItemClass;
    FItems: TIndexedBucketList;
    FNotIndexed: TList;
    FUpdateCount: Integer;
    function GetCount: Integer;
    procedure InsertItem(Item: TIndexedCollectionItem);
    procedure RemoveItem(Item: TIndexedCollectionItem);
    procedure UpdateIndex(Item: TIndexedCollectionItem);
  protected
    procedure Notify(Item: TIndexedCollectionItem; Action: TCollectionNotification); virtual;
    { Design-time editor support }
    procedure Changed;
    function GetItem(Index: Integer): TIndexedCollectionItem;
    procedure Update(Item: TIndexedCollectionItem); virtual;
    property UpdateCount: Integer read FUpdateCount;
  public
    constructor Create(ItemClass: TIndexedCollectionItemClass; Count:
        TBucketListSizes);
    destructor Destroy; override;
    function Add: TIndexedCollectionItem;
    procedure Assign(Source: TPersistent); override;
    procedure BeginUpdate; virtual;
    procedure Clear;
    procedure Delete(Index: Integer);
    procedure EndUpdate; virtual;
    function ForEach(AProc: TIndexedBucketProc; AInfo: TObject = nil): Boolean;
    function Insert(Index: Integer): TIndexedCollectionItem;
    property Count: Integer read GetCount;
    property ItemClass: TIndexedCollectionItemClass read FItemClass;
    property IndexedItems[Index: Integer]: TIndexedCollectionItem read GetItem;
  end;
 
  TIndexedCollectionItem = class(TPersistent)
  private
    FCollection: TIndexedCollection;
    FIndex: Integer;
    function GetIndex: Integer;
  protected
    procedure Changed(AllItems: Boolean);
    procedure SetCollection(Value: TIndexedCollection); virtual;
    procedure SetIndex(Value: Integer); virtual;
  public
    constructor Create(Collection: TIndexedCollection); virtual;
    destructor Destroy; override;
    property Collection: TIndexedCollection read FCollection write SetCollection;
    property Index: Integer read GetIndex;
  end;
 
implementation
uses Borland.Vcl.RTLConsts;
 
{ TIndexedCollection }
 
function TIndexedCollection.Add: TIndexedCollectionItem;
begin
  Result := FItemClass.Create(Self);
end;
 
procedure AssignItem(AInfo,AItem,AData:TObject;out AContinue : boolean);
begin
  if Integer(AItem)=0 then
    TIndexedCollection(AInfo).FNotIndexed.Add(AData)
  else
    TIndexedCollection(AInfo).Add.Assign(TPersistent(AData));
  AContinue:=true;
end;
 
procedure TIndexedCollection.Assign(Source: TPersistent);
begin
  if Source is TIndexedCollection then
  begin
    BeginUpdate;
    try
      Clear;
      TIndexedCollection(Source).ForEach(AssignItem,self);
    finally
      EndUpdate;
    end;
    Exit;
  end;
  inherited Assign(Source);
end;
 
procedure TIndexedCollection.BeginUpdate;
begin
  Inc(FUpdateCount);
end;
 
procedure TIndexedCollection.Changed;
begin
  if FUpdateCount = 0 then
    Update(nil);
end;
 
procedure FreeAll(AInfo,AItem,AData:TObject;out AContinue : boolean);
begin
  TIndexedCollection(AInfo).FItems.Remove(Integer(AItem));
  AData.Free;
  AContinue:=true;
end;
 
// Procédure TIndexedCollection.Clear
// Supprime les éléments de la liste et libère la mémoire associée.
procedure TIndexedCollection.Clear;
var
  I: Integer;
begin
  BeginUpdate;
  try
    FItems.ForEach(FreeAll,self);
    for I := FNotIndexed.Count - 1 downto 0 do
      TIndexedCollectionItem(FNotIndexed.Extract(FNotIndexed.Items[I])).free;
  finally
    EndUpdate;
  end;
end;
 
constructor TIndexedCollection.Create(ItemClass: TIndexedCollectionItemClass;
    Count: TBucketListSizes);
begin
  inherited Create;
  FItemClass := ItemClass;
  FItems := TIndexedBucketList.Create(Count);          
  FNotIndexed := TList.Create;
end;
 
procedure TIndexedCollection.Delete(Index: Integer);
var item : TIndexedCollectionItem;
begin
  item:=TIndexedCollectionItem(FItems.Remove(Index));
  Notify(item, cnDeleting);
  item.Free;
end;
 
destructor TIndexedCollection.Destroy;
begin
  FUpdateCount := 1;
  Clear;
  FItems.Free;
  FNotIndexed.Free;
  inherited Destroy;
end;
 
procedure TIndexedCollection.EndUpdate;
begin
  Dec(FUpdateCount);
  Changed;
end;
 
function TIndexedCollection.ForEach(AProc: TIndexedBucketProc;
  AInfo: TObject): Boolean;
var
  i: Integer;
begin
  for i := 0 to FNotIndexed.count - 1 do
  begin
    AProc(AInfo,TObject(0),FNotIndexed.Items[i],result);
    if not result then
      exit;
  end;
  result:=FItems.ForEach(AProc,AInfo);
end;
 
function TIndexedCollection.GetCount: Integer;
begin
  result:=FNotIndexed.Count+FItems.Count;
end;
 
function TIndexedCollection.GetItem(Index: Integer): TIndexedCollectionItem;
begin
  result:=TIndexedCollectionItem(FItems.Data[Index]);
end;
 
function TIndexedCollection.Insert(Index: Integer): TIndexedCollectionItem;
begin
  Result := Add;
  Result.SetIndex(Index);
end;
 
procedure TIndexedCollection.InsertItem(Item: TIndexedCollectionItem);
begin
  if not (Item is FItemClass) then
    TList.Error(SInvalidProperty, 0);
  if Item.FIndex<>0 then
    FItems.Add(Item.Index,Item)
  else
    FNotIndexed.Add(Item);
  Item.FCollection := Self;
  Notify(Item, cnAdded);
  Changed;
end;
 
procedure TIndexedCollection.Notify(Item: TIndexedCollectionItem;
  Action: TCollectionNotification);
begin
end;
 
procedure TIndexedCollection.RemoveItem(Item: TIndexedCollectionItem);
var
  AData: TObject;
begin
  Notify(Item, cnExtracting);
  if FItems.Find(TObject(Item.Index),AData) then
    FItems.Remove(Item.Index)
  else FNotIndexed.Remove(item);
  Item.FCollection := nil;
  Changed;
end;
 
procedure TIndexedCollection.Update(Item: TIndexedCollectionItem);
begin
end;
 
procedure TIndexedCollection.UpdateIndex(Item: TIndexedCollectionItem);
begin
  FNotIndexed.Extract(Item);
  FItems.Add(Item.Index,Item);
end;
 
{ TIndexedCollectionItem }
 
procedure TIndexedCollectionItem.Changed(AllItems: Boolean);
var
  Item: TIndexedCollectionItem;
begin
  if (FCollection <> nil) and (FCollection.FUpdateCount = 0) then
  begin
    if AllItems then
      Item := nil
    else
      Item := Self;
    FCollection.Update(Item);
  end;
end;
 
constructor TIndexedCollectionItem.Create(Collection: TIndexedCollection);
begin
  inherited Create;
  SetCollection(Collection);
end;
 
destructor TIndexedCollectionItem.Destroy;
begin
  SetCollection(nil);
  inherited;
end;
 
function TIndexedCollectionItem.GetIndex: Integer;
begin
  result:=FIndex;
end;
 
procedure TIndexedCollectionItem.SetCollection(Value: TIndexedCollection);
begin
  if FCollection <> Value then
  begin
    if FCollection <> nil then
      FCollection.RemoveItem(Self);
    if Value <> nil then
      Value.InsertItem(Self);
  end;
end;
 
procedure TIndexedCollectionItem.SetIndex(Value: Integer);
var
  CurIndex: Integer;
begin
  CurIndex := GetIndex;
  if (CurIndex = 0) and (CurIndex <> Value) then
  begin
    //Prévoir le changement d'index
    if FCollection<>nil then
      FCollection.UpdateIndex(self);
    Changed(True);
  end
  else if CurIndex>0 then
    EIndexedCollectionError.Create('Impossible de modifier l''index d''un élément');
end;
 
end.

et :

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
uses
  Borland.Vcl.Contnrs;
 
type
  TIndexedBucketList = class(TBucketList)
  protected
    function GetData(AItem: Integer): TObject;
    procedure SetData(AItem: Integer; const AData: TObject);
  public
    function Add(AItem: Integer; AData: TObject): TObject;
    function Remove(AItem: Integer): TObject;
    function getCount: Integer;
    property Count: Integer read getCount;
    property Data[AItem: Integer]: TObject read GetData write SetData; default;
  end;
 
implementation
 
{ TIndexedBucketList }
 
function TIndexedBucketList.Add(AItem: Integer; AData: TObject): TObject;
begin
  result:=inherited Add(TObject(AItem),AData);
end;
 
function TIndexedBucketList.getCount: Integer;
var
  i: Integer;
begin
  result:=0;
  for i := 0 to BucketCount - 1 do
    result:=result+Buckets[i].Count;
end;
 
function TIndexedBucketList.GetData(AItem: Integer): TObject;
begin
  result:=inherited Data[TObject(AItem)];
end;
 
function TIndexedBucketList.Remove(AItem: Integer): TObject;
begin
  result:= inherited Remove(TObject(AItem));
end;
 
procedure TIndexedBucketList.SetData(AItem: Integer; const AData: TObject);
begin
  inherited Data[TObject(AItem)] := AData;
end;
 
end.

Pour le deep copy et le framework je vais aller chercher.

Merci Laurent

Citation:

Envoyé par flash_math

Je souhaiterais que ce soit un plug-in qui fasse le transfert via le réseau afin de pouvoir à tout moment choisir un autre type de transfert que les composants Indy.

Tu penses utiliser des interfaces pour le découplage ?

Citation:

Envoyé par flash_math

(Je penses notamment à utiliser les possibilités de .Net).

Du peu que j'ai vu c'est beaucoup plus simple pour la sérialisation XML de plus il existe NHibernate.

Le sujet est intéressant en tout cas.

Pour le plug-In je ne sais pas encore quoi utiliser. Mais comme je travailles sur .Net aussi, je penses utiliser directement une classe même si les interfaces ne me dérange pas.

Pour le reste j'ai regardé un petit peu du côté de Windows Communication Foundation, mais il va falloir attendre Delphi 2007 for .Net, ou le .Net Remoting (pour lequel j'ai lu l'article auquel tu as contribué ;) ).