Discussion :

[bixi]

Salut

Je vous previens tout de suite, je débute sous Delphi (v6) et j'ai un peu de mal.. Malgré mes recherches sur developpez je reste bloqué.
Bon , j'ai créer une classe toute bete :

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
unit Client_annuaire;
(...)
type
   CClient = class
   private
      prenom: String;
      nom: String;
   public
        constructor Create(AOwner : TComponent; wprenom: String; wnom: String);
   end;
implementation
   constructor CClient.Create(AOwner : TComponent; wprenom: String; wnom: String);
   begin
       prenom := wprenom;
       nom := wnom;
   end;
 
end.

Que j'utilise dans mon prog principal (pour l'instant 2 champs texte et un bouton "enregistrer" :

Code :

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

1
2
3
4
5
6
7
8
9
procedure TForm2.img_bouton_saveClick(Sender: TObject);
var
     NouveauClient : CClient;
begin
     If txt_nom.Text <> '' then
          NouveauClient.Create(txt_prenom.Text, txt_nom.Text)
     else MessageBox(Form2.handle,'Veuillez renseigner le nom du nouveau
 client.','Erreur',MB_OK);
end;

Le probleme est que Delphi me sort une erreur :

Code :

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

1
2
3
4
5
 
Project1.exe raised exception class EaccessViolation with message 
'Access Violation at adress 4444c2etc  
in module Project1.exe. 
Write Of address 2312312. Process Stoped.

Où est le probleme? J'ai testé en virant le "AOwner : TComponent;" dans la description de la classe, c'est pareil. ya une histoire de "Self" a rajouté dans l'implementation?

Merci beaucoup pour votre aide, je continue a chercher de mon coté.
:hello:

[edit] J'ai modifié ton post pour rendre le code plus lisible. Les ascenceurs sont parfois génants [/edit]

[TicTacToe]

Ce n'est comme comme tu le fais qu'on instancie une classe:

Code :

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

 NouveauClient.Create(txt_prenom.Text, txt_nom.Text)

mais comme ceci

Code :

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

NouveauClient := CClient.Create( prenom,nom);

Mais je pense que tout le monde a fait l'erreur un jour ou l'autre
bon courage

[bixi]

Ha.. effectivement , Dephi a ses petites particularités qui échappe à mes yeux fatiguées :p

Merci du coup de mains, ca marche parfaitement maintenant :p


J'en profite pour une petite question en plus :

Je compte plutot enregistrer mes ojets dans un fichier sous forme de collections.
Sachant que je dois pouvoir faire des tris et que mes classes sont vraiment simples, je pensais utiliser TojectList. Est ce le meilleur choix? (je ne cherche, dans un premier temps, pas à faire un programme au top, mais un programme que je comprend :p, donc je vais au plus simple pour l'instant)

ps:je suis par contre obligé de passer par des ojets.. TstringList ne marche donc pas, je pense.

Merci encore

[TicTacToe]

Si j'ai bien compris, tu a une liste de client sous forme d'objet, et tu souhaites trier tes clients selon un certain critère.
Ce que je te conseille (mais il y a d'autres solutions je pense), c'est quand même d'utiliser une TStringList.

A chaque element d'une stringlist, tu as le couple (chaine/objet) que tu alimentes avec

MaStringList.AddObject( 'chaine', NouveauClient );

Par défaut, tu ne peux trier ta stringList que par chaine (qui pourrait être le nom), MAIS tu peux également trier ta liste par objet en implémentant ta propre fonction de comparaison pour trier selon les objets associés.

Pour cela, regarde du coté de

Code :

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

TStringList.CustomSort( fonction Callback de comparaison)

tu pourras ainsi trier ta liste selon le critère de comparaison dans ta fonction callback de comparaison primaire.

[bixi]

Re-salut

Merci pour tes réponses, c'est tres sympa de m'aider.

J'ai encore un peu de mal a cerner le probleme.
Quel est le rapport entre une chaine et un objet quand tu dis :
"tu as le couple (chaine/objet) "

J'ai bien des chaines mais ce sont des attribus de mon objet.

Sinon pour les tris, c'est secondaire, je vais pas me prendre la tete maintenant avec ca..

En depuis maintenant quelques heures j'essayes juste de sauvegarder une collection d'objet Client dans un fichier :/

Je suis sur le point de craquer mais je persiste

Merci encore

[Fabrice ROUXEL 1]

Quel est le rapport entre une chaine et un objet quand tu dis :
"tu as le couple (chaine/objet) "

A chaque chaine est associé un pointeur permettant au programmeur de définir un type de données associé à cette chaine.
Par exemple tu peux avoir une liste de chaines de caracteres (qui representent les noms des clients) et leurs associer un objet tclient.

CustomSort te permet de définir une fonction de trie personnalisée et adaptée à ta classe TClient.

[Pascal Jankowski]

Je pense qu'il faut que tu revoies la conception de tes classes. En effet, pour pouvoir sauver les éléments de ta liste, tu dois t'appuyer sur des classes sérialisables (descendant de TPersistent).

Dans ton cas, il faudrait que tu utilises une classe de type TCollection dont les items sont des TCollectionItem que tu définis toi même.

Cordialement

[bixi]

Bon he bien, c'est officiel je laisse tomber le Delphi..
J'ai jamais passé plus de 8h (toute la nuit) pour seulement "tenté" d'enregistrer des données dans un fichier.. C'est pas croyable.

J'ai l'impression de perdre mon temps c'est insuportable..

J'ai essayé des TstringList, des TobjectList.. la j'ai regardé le .pdf de Sylvain James sur les collections. et apparement la classe Tcollection on peut pas faire plus compliqué. (Tpersistent, désolé mais je craque, je plus la force de me documenter sur des classes qui me feront pas sortir du tunnel avant 3 semaines)

Donc si vous avez une solution miracle.. je veux bien prendre :/

Je suis rendu a ce niveau dans ma fonction en tout cas :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
procedure TForm2.img_bouton_saveClick(Sender: TObject);
var
     NouveauClient : CClient;
     MesClients : TObjectList;
begin
     If txt_nom.Text <> '' then
     begin
          MesClients :=  TObjectList.Create;
          NouveauClient:= CClient.Create(txt_prenom.Text, txt_nom.Text);
          MesClients.Add(NouveauClient);
     end
     else MessageBox(Form2.handle,'Veuillez renseigner le nom du nouveau client.','Erreur',MB_OK);
end;

A priori ca marche, mais je ne sais pas comment sauvegarder ca dans un fichier.

Merci encore..

[Fabrice ROUXEL 1]

Bon he bien, c'est officiel je laisse tomber le Delphi.

BDS 2005 facilite grandement l'enregistrement de classes sans devoir utiliser explicitement les classes de flux.
Donc il n'y a plus la necessité de dériver de TPersistant, gérer des TCollections etc...
Un simple tag [serializable] devant la declaration de classe indique à Delphi que l'on souhaite avoir une classe serialisable, et c'est tout rien de plus à coder

[bixi]

Ok Ok, la petite lumière au bout du tunel se fait plus visible.

BDS 2005 : c'est ca:
http://delphi.developpez.com/delphi2005/ ?
Ne vas t'il pas y avoir de probleme vu que je code avec Delphi6 ?
(quoi que j'ai pas fait grand chose, je peut bien tout refaire)

Sinon, le bout de code que j'ai montré semble marcher.
par contre j'ai , je crois, bidouillé, car j'ai enlevé tout ce qui avait rapport avec des pointeurs . Or un TOjectList marche avec des pointeurs non?

Merci!

[Fabrice ROUXEL 1]

par contre j'ai , je crois, bidouillé, car j'ai enlevé tout ce qui avait rapport avec des pointeurs

Pour les bidouilles, voir cela avec Waskol

[Pascal Jankowski]

Suite à ma remarque précédente, je vais te présenter une méthode qui va permettra de gérer ton annuaire client en dérivant un descendant de TCollection. Chaque item de TCollection sera également un descendant de TCollectionItem. Cette dernière sera la classe qui va gérer chaque fiche de ton annuaire.

Pour terminer, une troisième classe intervient et dérive de TComponent. Cela permettra de sauver ton annuaire sous forme d'un fichier grâce à la routine WriteComponentResFile.
Ultérieurement tu relieras ton fichier avec la fonction ReadComponentResFile, qui restaurera les données.

Cette façon de faire est parfaitement documentée dans le livre d'Olivier Dahan.
J'ai rapidement repris le bout de code et l'ai adapté à ton problème.

Les classes utilisées sont les suivantes :
TClient descendante de TCollectionItem
TListeClient descendante de Tcollection
et
TFichierClient descendant de Tcomponent

Voilà le code de l'unité qui gère ton annuaire

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
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
unit Unit2;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;
 
 Type
   TFichierClient = Class;
 
   TClient = Class(TCollectionItem)
   private
     FclientName: string;
     FclientSurname: string;
     procedure SetclientName(const Value: string);
     procedure SetclientSurname(const Value: string);
    protected
     function GetDisplayName: string; override;
    public
     constructor Create(Collection: TCollection); override;
     procedure Assign(Source: TPersistent); override;
    published
     property clientName:string read FclientName write SetclientName;
     property clientSurname:string read FclientSurname write SetclientSurname;
    end;
 
   TListeClient = Class(Tcollection)
    private
     Ffichier : TFichierClient;
     function GetItem(index:integer):TClient;
     procedure SetItem(index:integer;Value:TClient);
    protected
     function GetOwner:TPersistent; override;
     procedure Update(Item: TCollectionItem); override;
    public
     constructor create(fichier:TFichierClient);
     function Add : TClient;
     property Items[index:integer] : TClient read GetItem write SetItem; default;
    end;
 
   TFichierClient = Class(Tcomponent)
    private
     fItems : TListeClient;
     procedure setItems(value:TListeClient);
    public
     constructor create(AOwner:Tcomponent); override;
     destructor destroy; override;
     procedure ListeModifiee(Item:TClient);
    published
     property Items : TListeClient read fItems write SetItems;
    end;
 
implementation
 
//*****************************************************************************
 {TClient}
 
constructor TClient.Create(Collection: TCollection);
begin
 inherited create(Collection);
end;
 
procedure TClient.SetclientName(const Value: string);
begin
 if FclientName <> Value
  then begin
           FclientName := Value;
           Changed(false);
        end;
end;
 
procedure TClient.SetclientSurname(const Value: string);
begin
 if FclientSurname <> Value
   then begin
            FclientSurname := Value;
            Changed(false);
         end;
end;
 
function TClient.GetDisplayName: string;
begin
 if clientName <>''
   then result := 'Client : ' + ClientName
   else result := inherited GetDisplayName;
end;
 
procedure TClient.Assign(Source: TPersistent);
begin
  if Source is TClient then
  begin
    clientName := TClient(Source).clientName;
    clientSurname := TClient(Source).clientSurname;
    Exit;
  end;
  inherited Assign(Source);
end;
 
//*****************************************************************************
{ TListeClient }
 
function TListeClient.GetItem(index:integer):TClient;
begin
 Result := TClient(inherited GetItem(Index));
end;
 
procedure TListeClient.SetItem(index:integer;Value:TClient);
begin
 inherited SetItem(Index, Value);
end;
 
function TListeClient.GetOwner:TPersistent;
begin
 Result := Ffichier;
end;
 
constructor TListeClient.create(fichier:TFichierClient);
begin
 inherited create(TClient);
 Ffichier := fichier;
end;
 
function TListeClient.Add : TClient;
begin
 Result := TClient(inherited Add);
end;
 
procedure TListeClient.Update(Item: TCollectionItem);
begin
 Ffichier.ListeModifiee(TClient(item));
end;
 
//*****************************************************************************
{ TFichierClient}
 
procedure TFichierClient.setItems(value:TListeClient);
begin
 FItems.Assign(Value);
end;
 
constructor TFichierClient.create(AOwner:Tcomponent);
begin
 inherited Create(AOwner);
 FItems := TListeClient.Create(Self);
end;
 
destructor TFichierClient.destroy;
begin
 FItems.Free;
 inherited Destroy;
end;
 
procedure TFichierClient.ListeModifiee(Item:TClient);
begin
 if Item=nil 
   then Showmessage('Toute la liste a été modifiée')
   else Showmessage('La fiche  '+Item.GetDisplayName+' a été modifiée');
end;
 
end.

Voici maintenant le code qui utilise la classe TFichierClient
Pour utiliser cet exemple il faudra que tu places sur ta fiche les composants ci-dessous surlignés en rouge

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
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
unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, unit2, StdCtrls;
type
  TForm1 = class(TForm)
    btnRemplir: TButton;
    btnAfficher: TButton;
    ListBox1: TListBox;
    btnSauver: TButton;
    btnCharger: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnRemplirClick(Sender: TObject);
    procedure btnAfficherClick(Sender: TObject);
    procedure btnSauverClick(Sender: TObject);
    procedure btnChargerClick(Sender: TObject);
  private
    { Déclarations privées }
    mesClients : TFichierClient;
  public
    { Déclarations publiques }
  end;
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  mesClients := TFichierClient.create(self);
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  mesClients.free;
end;
 
procedure TForm1.btnRemplirClick(Sender: TObject);
begin
 mesClients.Items.BeginUpdate;
 try
   with mesClients.Items.Add do
   begin
     clientName := 'Dupont';
     clientSurname := 'Jacques';
   end;
   with mesClients.Items.Add do
    begin
      clientName := 'Martin';
      clientSurname := 'Pierre';
    end;
   with mesClients.Items.Add do
    begin
      clientName := 'Duchemin';
      clientSurname := 'Eric';
    end;
 finally
  mesClients.Items.EndUpdate;
 end;
end;
 
 
procedure TForm1.btnAfficherClick(Sender: TObject);
var i:integer;
begin
  listbox1.clear;
  for i:= 0 to mesClients.Items.Count-1 do
     listbox1.Items.Append(mesClients.Items.clientName+': '
                         +mesClients.Items.ClientSurname);
end;
 
 
//*****************************************************************************
procedure TForm1.btnSauverClick(Sender: TObject);
begin
   WriteComponentResFile('Test.dat',mesClients);
end;
 
procedure TForm1.btnChargerClick(Sender: TObject);
begin
   ReadComponentResFile('test.dat',mesClients);
end;
 
end.

Tente déjà de faire tourner cet exemple. Je tenterai de répondre à tes questions voire de t'aider à aller un peu plus loin car ce code reste minimaliste et tu vas certainement vouloir lui adapter de nouvelles fonctions.

Comme tu débutes avec Delphi, c'est le moment pour acquérir les bons réflexes.


@+

[Pascal Jankowski]

Un simple tag [serializable] devant la declaration de classe indique à Delphi que l'on souhaite avoir une classe serialisable, et c'est tout rien de plus à coder

Sur un nouveau projet delphi 2005 utilisant la VCL.NET, je suis d'accord. Mais sur un projet VCL classique [serializable] n'est pas reconnu à la compilation.
Serrait-ce un bug de D2005 ou une spécificité de .Net ?

[bixi]

Salut

Merci beaucoup pour cet exemple, il a l'air.. super !

je vais me pencher dessus des que j'aurais defragmenter mon Disque Mou Interne (cerveau ). Ca fait plus de 24h que j'ai pas dormi . je m'accorde une pause


Sinon:

BDS 2005 facilite grandement l'enregistrement de classes sans devoir utiliser explicitement les classes de flux.
Donc il n'y a plus la necessité de dériver de TPersistant, gérer des TCollections etc...
Un simple tag [serializable] devant la declaration de classe indique à Delphi que l'on souhaite avoir une classe serialisable, et c'est tout rien de plus à coder

J'ai téléchargé BDS2006 (mieu que 2005 j'espere?), Peut etre la solution pourrait etre plus simple ?

M'enfin, je verrais tout ca a tete reposée demain.

Merci beaucoup à vous. Bonne soirée

[bixi]

Bon he bien, Merci beaucoup Pascal Jankowski, j'ai réussi a m'en sortir parfaitement.. J'arrive bien a tout utiiser c'est parfait.. Il ya quelques petites choses que je ne comprend pas dans l'unit2 mais ca devrait aller


Merci encore ! a bientot (j'espere pas ! )

[OutOfRange]

je vais me pencher dessus des que j'aurais defragmenter mon Disque Mou Interne (cerveau )

Je suis très impressionné... par l'humour d'un programmeur... au bord de l'agonie
"Disque mou"... Je la replacerai celle-là... avec ton autorisation bixi

Et encore chapeau bas pour ta persévérance

Bonne prog

[bixi]

Je t'en prie

C'est vrai que c'est de l'humour purement informatique.. c'est pas bon d'en arriver la Mon dieu, je suis perdu :p

Bon week end

[bixi]

Bonjour

J'ai presque fini mon application (annuaire) et la derniere fonction sur laquelle je m'attele est la suppression d'un Client de ma collection de Client.

Or, la je suis bloqué.. je n'arrive pas à trouver comment coder cette fonction. Je précise que je m'appuye totalement sur l'exemple de Pascal Jankowski.

Il doit falloir créer une procédure :
procedure TListeClient.deleteItem(index:integer;
mais que mettre dedans?
faut il gérer le décalage des index de client vu qu'on en supprimer un?

Merci

[Pascal Jankowski]

tout simplement de la façon suivante

Code :

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

1
2
 
mesClients.Items[indice_client].Free;

Items n'est rien d'autre qu'une liste, manipulable comme un listBox par exemple. Tu ne touches a rien en ce qui concerne les index.

Cordialement

[bixi]

He bien, merci encore, je ne pensais pas que c'etait si simple

Bonne journée