Problème de callback avec des paramètres

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:

---

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:

---

1 2 3 4 5 6 7 8

procedure callbackProcess1;   ..... traite := TTraite.Create; traite.myCalback := callbackProcess1; traite.Lance; ...

---

ou, pour le process 2

Code:

---

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:

---

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

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

Code:

---

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.

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

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:

---

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:

---

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;

---

je suis d'accord avec Shai

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

Code:

---

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é :)

Citation:

---

Envoyé par ShaiLeTroll

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. :mrgreen:

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:

---

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

---

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

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 :aie:

Citation:

---

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:

---

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);

---

Citation:

---

Envoyé par sevyc64

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

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:

---

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:

---

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:

---

1 2 3 4 5 6 7 8

traite := TTraite.Create; try traite.myCalback := callbackProcess2; traite.Lance; finally traite.Free(); end;

---

Code:

---

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 !

Ok, merci pour tout.

Je pense que le refactoring est incontournable, autant faire du code propre, même s'il fait tâche à coté du code bien pourri déjà existant.

Pour l'instant en debug, j'ai fait une variable globale pour pouvoir avancer dans mon code. Je corrigerais par la suite en faisant les choses correctement.