Discussion :

[sevyc64]

Salut à tous, je plante le décors.

J'ai un traitement générique qui peut être appelé par différents process. Ce traitement, avant de se terminer doit faire quelques petites choses qui, elles, sont spécifique en fonction du process appelant.Pour cela, j'utilise un système de CallBack pour que mon traitement générique appelle toujours la même méthode.

Donc dans mon traitement j'ai quelque chose de la sorte (pas du tout sur du code, je l'ai pas sous la main, je fais de tête):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Type
TMyCallback = procedure() of object;
 
TTraite = class()
  myCallback : TMyCallback;
  procedure Lance;
  .....
procedure Lance
begin
......
If Assigned(myCallback) then myCalback;
......
end;

Dans mes process, avant de lancer mon traitement, j'ai des instructions de la sorte pour le process 1 :

Code :

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

1
2
3
4
5
6
7
8
 
 procedure callbackProcess1;
 
  .....
  traite := TTraite.Create;
  traite.myCalback := callbackProcess1;
  traite.Lance;
...

ou, pour le process 2

Code :

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

1
2
3
4
5
6
7
8
 
 procedure callbackProcess2;
 
  .....
  traite := TTraite.Create;
  traite.myCalback := callbackProcess2;
  traite.Lance;
...

etc ...

Maintenant, je rajoute un nouveau process qui, lui, aura besoin de passer un paramètre à la fonction de callback

Code :

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

1
2
3
4
5
6
7
8
 
 procedure callbackProcessEnquiquineur(toto as string);
 
  .....
  traite := TTraite.Create;
  traite.myCalback := callbackProcessEnquiquineur('Pour pas faire comme les autres');
  traite.Lance;
...

Évidemment, cela ne marche pas.
Donc pour résumer, j'ai x callback qui ne nécessitent pas de paramètres, mais là je rajoute un callback qui, lui aura un paramètre. Et peut-être qu'à l'avenir il y en aura d'autres avec potentiellement un paramètre de type différent, avec potentiellement plusieurs paramètres, etc ...

Existe-il une solution, je sais pas peut-être un système de paramètres optionnels de type génériques, un tableau de variant peut-être, je sais pas
où je dois accepter de me dépanner avec une vilaine variable globale à la place du paramètre ?
C'est bien plus simple, mais c'est pas propre

Et j'ai oublié l'essentiel : DELPHI 6

[guillemouze]

Dans ces situations, en général, j'utilise la technique windows : LParam;

Code :

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

TMyCallback = procedure(LParam: Pointer) of object;

Avec ca tu mets ce que tu veux dedans, l'important c'est que l'appelant et l'appelé soient d'accord sur le contenu de ce pointeur.

[tourlourou]

Ou passer un array of const (TvarRec) comme dans la fonction Format ; voir ici.

[ShaiLeTroll]

Tu confonds l'appel du CallBack et le passage de l'adresse du CallBack

Si tu dois gérer des paramètres polymorphes, le mieux serait de passer un TObject
Avec les opérateurs is et as tu pourras facilement récupérer ton objet (ou ni si tu n'as pas besoin d'exploiter la valeur)

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
Type
TMyCallback = procedure(Data: TObject) of object
 
TTraite = class()
  myCallback : TMyCallback;
  myCallbackContext: TObject;
  procedure Lance;
  .....
procedure Lance
begin
......
If Assigned(myCallback) 
  then myCalback(myCallbackContext);
......
end;

Dans ce code tu as confonds l'appel callback (ci-dessus) et le passage d'adresse

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  traite := TTraite.Create;
  try
    traite.myCallbackContext:= TEnquiquineur.Create('Pour pas faire comme les autres');
    try
      traite.myCallback := callbackProcessEnquiquineur; // Ici tu avais confondu appel et passage de l'adresse
      traite.Lance();
    finally
      traite.myCalbackObjet.Free();
    end;
  finally  
    traite.Free();
  end;

[Paul TOTH]

je suis d'accord avec Shai

sinon avec les fonctions anonymes il est aussi possible de s'en sortir

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
type
  TCallBack = reference to procedure;
 
var
  p1: Integer;
begin
  appel(procedure begin ShowMessage('pas de paramètre'); end);
  appel(procedure begin ShowMessage('paramètre = toto en dur'); end);
  appel(procedure begin ShowMessage('paramètre capturé = ' + IntToStr(p1)); end);
end;

dans ce contexte, la variables sont "capturées", ce qui est aussi source de joyeux bugs quand c'est mal utilisé

[sevyc64]

Tu confonds l'appel du CallBack et le passage de l'adresse du CallBack

C'était voulu, c'était pour montrer que cette procédure là nécessitait un paramètre contrairement aux autres.

Avec ton code, je dois modifier toutes mes procédures pour qu'elles acceptent un paramètre et pour qu'elles soient conforme à la signature du callback.
A moins que je puisse faire un appel du genre ?

Code :

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

1
2
If Assigned(myCallback) then 
  if Assigned(myCallbackContext) then myCalback(myCallbackContext) else myCalback;

[skywaukers]

Bonjour,

peut-être en définissant des classes qui hériteraient de TTraite, en déclarant la procédure Lance Virtual chaque classe "héritière" pourraient la compléter avec l'appel de la méthode spécifique qui serait définie à son niveau.

@++
Dany

[guillemouze]

Effectivement, j'ai regardé un peu trop vite ton problème.
J'aurai un petit penchant pour la solution de Paul, mais en D6, tu peux oublier les fonctions anonymes

Avec ton code, je dois modifier toutes mes procédures pour qu'elles acceptent un paramètre et pour qu'elles soient conforme à la signature du callback

Dans tout les cas tu va devoir y passer, ta callback a un type qui ne correspond pas a ton enquiquineur, donc
soit tu met un contexte comme le propose judicieusement Shai,
soit tu met un string en parametre, qui ne sera pas utilisé par les autres callbacks
soit tu utilise une variable globale (un peu crade, mais te permet de garder la signature de ta fonction)
NB : c'est cette dernière technique que j'utilise pour trier une TList de manière paramétrable, par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
var
___FSortDistancePoint___: TPoint;
function SortDistancePoint(i1, i2: TObject): integer;
begin
  Result := CompareValue(Dist(TCercle(i1).centre, ___FSortDistancePoint___), Dist(TCercle(i2).centre, ___FSortDistancePoint___));
end;
...
 
___FSortDistancePoint___ := Point(10,15);
MonObjectlist.sort(SortDistancePoint);

[ShaiLeTroll]

C'était voulu, c'était pour montrer que cette procédure là nécessitait un paramètre contrairement aux autres.

Avec ton code, je dois modifier toutes mes procédures pour qu'elles acceptent un paramètre et pour qu'elles soient conforme à la signature du callback.
A moins que je puisse faire un appel du genre ?

Code :

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

1
2
If Assigned(myCallback) then 
  if Assigned(myCallbackContext) then myCalback(myCallbackContext) else myCalback;

Si tu as la flemme de faire le refactoring de masse

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
Type
  TMyCallback = procedure() of object;
  TMyCallbackWithContext = procedure(Data: TObject) of object;
 
TTraite = class()
  myCallback : TMyCallback;
  myCallbackWithContext: TMyCallbackWithContext ;
  myCallbackContext: TObject;
  procedure Lance;
  .....
procedure Lance
begin
......
 if Assigned(myCallbackWithContext) and Assigned(myCallbackContext) then
     myCallbackWithContext(myCallbackContext) 
 else if Assigned(myCallback) then 
     myCalback;
......
end;

Code :

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

1
2
3
4
5
6
7
8
 
  traite := TTraite.Create;
  try
    traite.myCalback := callbackProcess2;
    traite.Lance;
  finally  
    traite.Free();
  end;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
traite := TTraite.Create;
  try
    traite.myCallbackContext:= TEnquiquineur.Create('Pour pas faire comme les autres');
    try
      traite.myCallbackWithContext := callbackProcessEnquiquineur; // Ici tu avais confondu appel et passage de l'adresse
      traite.Lance();
    finally
      traite.myCalbackObjet.Free();
    end;
  finally  
    traite.Free();
  end;

En fait, tu fais des classes avec des évènements, en général, j'utilise par défaut un TNotifyEvent, c'est le type minimale que j'utilise
Si j'ai besoin de spécialiser, je ne me gène pas à faire des évènements spécifiques !