Discussion :

[Andry]

Salut à tous.
J'ai une classe de base

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
 
  TAncestorClass = Class
  private
    FErrorNum: TErrorType;
    FInternalNum: Integer;
    FErrorDesc: String;
    FonError: TNotifyEvent;
    procedure SetErrorDesc(const Value: String);
    procedure SetErrorNum(const Value: TErrorType);
    procedure SetInternalNum(const Value: Integer);
    procedure SetonError(const Value: TNotifyEvent);
  protected
    procedure DoError;
    property  OnError      : TNotifyEvent read FOnError write SetOnError;
  published
    property InternalNum  : Integer read FInternalNum write SetInternalNum;
    property ErrorNum     : TErrorType read FErrorNum write SetErrorNum;
    property ErrorDesc    : String read FErrorDesc write SetErrorDesc;
  end;
Implementation
 
procedure TAncestorClass.DoError;
begin
  If Assigned(FOnError) then
    FOnError(Self);
end;
 
procedure TAncestorClass.SetErrorDesc(const Value: String);
begin
  If FErrorDesc <> Value then
    FErrorDesc := Value;
end;
 
procedure TAncestorClass.SetErrorNum(const Value: TErrorType);
begin
  If FErrorNum <> Value then
  begin
    FErrorNum := Value;
    if FErrorNum = etError then
      DoError;
  end;
end;
 
procedure TAncestorClass.SetInternalNum(const Value: Integer);
begin
  If FInternalNum <> Value then
    FInternalNum := Value;
end;
 
procedure TAncestorClass.SetOnError(const Value: TNotifyEvent);
begin
  FOnError := Value;
end;

deux classe descendant TChildAClass et tChildBClass qui sont similaire (pour le test)

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
 
  TChildBClass  = Class(TAncestorClass)
  private
    FStrOne: String;
    procedure SetStrOne(const Value: String);
  published
    property StrOne : String read FStrOne write SetStrOne;
    property OnError;
  end;
implementation
procedure TChildAClass.SetStrOne(const Value: String);
begin
  if FStrOne <> Value then
  begin
    FStrOne := Value;
    if Length(FStrOne) > 15 then
    begin
      ErrorDesc  := 'Length string out of range in class : '+Self.ClassName;
      ErrorNum   := etError;
      FStrOne := '';
    end;
  end;
end;

Une autre classe heritant de TAnestorClass et qui instancie les 2 autres classes

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
 
  TMixClass = Class(TAncestorClass)
  private
    FChildA: TChildAClass;
    FChildB: TChildBClass;
    procedure SetChildA(const Value: TChildAClass);
    procedure SetChildB(const Value: TChildBClass);
  published
    property ChildA : TChildAClass read FChildA write SetChildA;
    property ChildB : TChildBClass read FChildB write SetChildB;
    property OnError;
  public
    constructor create;
    destructor destroy; Override;
  end;
implementation
constructor TMixClass.create;
begin
  Inherited Create;
  ChildA  := TChildAClass.Create;
  ChildB  := TChildBClass.Create;
end;
 
destructor TMixClass.destroy;
begin
  ChildA.Free;
  ChildB.Free;
  inherited;
end;
 
procedure TMixClass.SetChildA(const Value: TChildAClass);
begin
  FChildA := Value;
end;
 
procedure TMixClass.SetChildB(const Value: TChildBClass);
begin
  FChildB := Value;
end;

La question :
Comment implementer l'event OnError au niveau de TMixClass pour que les OnError de ChildA et ChildB soit intercepté.

Merci

[e-ric]

Salut


Si j'ai bien compris ton problème, la solution est simple :

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
 
TMixClass = Class(TAncestorClass)
  private
    FChildA: TChildAClass;
    FChildB: TChildBClass;
    procedure SetChildA(const Value: TChildAClass);
    procedure SetChildB(const Value: TChildBClass);
  published
    property ChildA : TChildAClass read FChildA write SetChildA;
    property ChildB : TChildBClass read FChildB write SetChildB;
    property OnError;
  public
    constructor create;
    destructor destroy; Override;
  end;
implementation
constructor TMixClass.create;
begin
  Inherited Create;
  FChildA := TChildAClass.Create;
  FChildA.OnError := OnError;
  FChildB := TChildBClass.Create;
  FChildB.OnError := OnError;
end;
 
destructor TMixClass.destroy;
begin
  ChildA.Free;
  ChildB.Free;
  inherited;
end;
 
procedure TMixClass.SetChildA(const Value: TChildAClass);
begin
  FChildA := Value;
  FChildA.OnError := OnError;
end;
 
procedure TMixClass.SetChildB(const Value: TChildBClass);
begin
  FChildB := Value;
  FChildB.OnError := OnError;
end;

est-ce ce que tu attendais ?

Remarque 1 : TMixClass est par construction propriétaire de ChildA et ChildB (TMixClass assure la création et la destruction de ces objets) or tu donne accès en écriture à ces objets, c'est risqué.

Remarque 2 : Un événement n'est pas implémenté au niveau d'une classe mais rattaché à une instance de cette classe.

cdlt

e-ric

[Andry]

En faites j'aimerais faires simplement :
FOnError = FChildA.OnError or FChildB.OnError

Comment realiser cela.

Car actuellement, je dois faire comme ceci pour arriver à mes fin :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
procedure TForm1.OnMixError(Sender: TObject);
begin
  MessageDlg(Pchar((Sender as TAncestorClass).ErrorDesc), mtError, [mbOK], 0);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Mix := TMixClass.create;
  Mix.ChildA.OnError  := OnMixError;
  Mix.ChildB.OnError  := OnMixError;
end;

Merci

[e-ric]

je ne comprend pas bien ceci :

En faites j'aimerais faires simplement :
FOnError = FChildA.OnError or FChildB.OnError

Comment realiser cela.

Car actuellement, je dois faire comme ceci pour arriver à mes fin :

Code:
procedure TForm1.OnMixError(Sender: TObject);
begin
MessageDlg(Pchar((Sender as TAncestorClass).ErrorDesc), mtError, [mbOK], 0);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
Mix := TMixClass.create;
Mix.ChildA.OnError := OnMixError;
Mix.ChildB.OnError := OnMixError;
end;
Merci

Veux-tu affecter automatiquement les 2 événements FChildA.OnError or FChildB.OnError à l'affectation de MixClass.OnError ?

e-ric

[Andry]

Salut,
Pour plus d'infos, les classes seront utilisés pour des saisies avec des controles très rigoureux (genre nb car, contenue, etc), donc j'ai implementé un evenement OnError et verifie chaque affectation de valeur et si valeur non conforme, on stop tout au niveau de l'appli.
La saisie concerne pas mal de domaine donc j'ai découpé en plusisuers classes afin de rendre la maintenance plus aisée.

J'ai le choix entre deux utilisation :
- Soit déclarer des objets de type ChildX et utiliser ces objets directement. (Celui ci est bon, ça marche)
- Soit créer une Class qui incorpore tous les childs et instancié celui ci.
C'est cette dernière que j'essaie de mettre en oeuvre, mais je me butte sur l'evenement OnError. Comment au niveau de TMixClass, savoir qu'un Event s'est produit dans ces membres.

Merci

[e-ric]

Il est difficile de déterrminer si un événement a été déclenché, un événement est une adresse de méthode (deux pointeurs en fait).

Une solution consiste à notifier l'exécution de l'événement OnError à ton objet TMixClass.

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
 
  TMixClass = Class(TAncestorClass)
  private
    FChildA: TChildAClass;
    FChildB: TChildBClass;
    procedure SetChildA(const Value: TChildAClass);
    procedure SetChildB(const Value: TChildBClass);
  published
    property ChildA : TChildAClass read FChildA write SetChildA;
    property ChildB : TChildBClass read FChildB write SetChildB;
    property OnError;
  public
    constructor create;
    destructor destroy; Override;
    procedure NotifyError(Error: TAncestorClass);
  end;
 
implementation
 
constructor TMixClass.create;
begin
  Inherited Create;
  ChildA  := TChildAClass.Create;
  ChildB  := TChildBClass.Create;
end;
 
destructor TMixClass.destroy;
begin
  ChildA.Free;
  ChildB.Free;
  inherited;
end;
 
procedure TMixClass.SetChildA(const Value: TChildAClass);
begin
  FChildA := Value;
end;
 
procedure TMixClass.SetChildB(const Value: TChildBClass);
begin
  FChildB := Value;
end;
 
procedure TMixClass.NotifyError(Error: TAncestorClass);
begin
// le code de traitement
End;
// -------------------------------------------------
// puis dans le code client
procedure TForm1.OnMixError(Sender: TObject);
begin
  if Sender is TAncestorClass then
  begin
    Mix.NotifyError(Sender as TAncestorClass)
    MessageDlg(Pchar((Sender as TAncestorClass).ErrorDesc), mtError, [mbOK], 0);
  end;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Mix := TMixClass.create;
  Mix.ChildA.OnError  := OnMixError;
  Mix.ChildB.OnError  := OnMixError;
end;

Cela a le mérite d'être simple. Est-ce que cela te suffit ?

Il est possible de rendre la notification implicite et éviter ainsi l'appel Mix.NotifyError; mais il faut modifier la conception de tes classes TMixClass et TChilX de façon à implémenter clairement les relations de composant(TChilX) à composé (TMixClass).

cdlt

e-ric