Combiner des procédures et des méthodes

Testé sous Xp et Delphi 2006.

I-A. Les sources▲

Comme nous le dit la documentation de Delphi :

Les types procédure permettent de traiter des procédures et des fonctions comme des valeurs pouvant être affectées à des variables 
ou transmises à d'autres procédures ou fonctions.
...
Deux types de procédures sont compatibles si :
- Ils ont la même convention d'appel. 
- Ils renvoient le même type de valeur ou pas de valeur. 
- Ils ont le même nombre de paramètres, avec le même type aux mêmes positions. Le nom des paramètres est sans importance.

Une variable de type procédure peut également se rapprocher du type pointeur, ces types étant compatibles dans les affectations.

Déclarons un type procédure :

type
 TProcedureTypee = Procedure(Element : String);

On peut dès lors l'utiliser comme paramètre d'une procédure :

procedure Enumere(Collection: TStringDynArray ; Traitement:TProcedureTypee);
{Énumère une collection de données en traitant chaque élément}
var  I       : Integer;
begin
  for i := Low(Collection) to High(Collection) do
   Traitement(Collection[i]);
end;

La procédure de traitement, passée en paramètre, doit respecter la signature du type déclaré :

Procedure AfficheTableau(Element : String);
begin
  Writeln(Element);
end;

Bien évidemment ici cette approche semble suivre le principe du pourquoi faire simple quand on peut faire compliqué ?
On peut, dans notre cas, envisager des traitements différents lors de l'itération de notre collection, par exemple l'écrire dans un fichier, sur un port série, etc.

L'appel de notre procédure peut se faire directement en utilisant l'opérateur @ :

var   I       : Integer;
      tabNom  : TStringDynArray;

begin
try
   //Crée le tableau et le peuple
  SetLength(tabNom,10+1);
  For I:=0 to 10 do
    tabNom[I]:=Chr(I+65);
  Enumere(tabNom, @AfficheTableau);
  Readln;
finally
 Finalize(tabNom);
end;

Il reste possible d'utiliser une variable :

var MaProcedure : TProcedureTypee;
begin 
 ...
 maProcedure : = @AfficheTableau;
 Enumere(tabNom, MaProcedure);
 ...

À la différence du type procédural, le type méthode d'objet se déclare en ajoutant le mot clé of object :

type
  TProcedureObjet = Procedure(Element : String) of object;

On remarquera que nos deux déclarations sont très semblables.

Déclarons notre classe pour héberger notre méthode Affiche :

TUneClasse =Class
 private
  FProcedure : TProcedureObjet; 
 public
  Procedure Affiche(Element : String); 
  Procedure Iteration(Collection: TStringDynArray);
  property Traitement: TProcedureObjet read FProcedure write FProcedure;
 End;

Son implémentation étant la suivante :

{ TUneClasse }
procédure TUneClasse.Affiche(Element: String);
begin
   Writeln(Element);
end;

procédure TUneClasse.Iteration(Collection: TStringDynArray);
var
  I       : Integer;
begin
  if Assigned(Traitement) then
   for i := Low(Collection) to High(Collection) do
    Traitement(Collection[i]);
end;

On utilisera cette méthode d'objet ainsi :

  UnObjet:= TUneClasse.Create;
  UnObjet.Traitement:=UnObjet.Affiche; //Affecte la méthode d'objet.
  UnObjet.Iteration(tabNom); //Exécute le traitement
  Readln;

Notez que l'on peut affecter à la propriété Traitement n'importe quelle méthode de toute classe, elle doit juste respecter la signature déclarée dans le type.

  UnObjet:= TUneClasse.Create;
  UnAutreObject := TUneAutreClasse.Create;
  UnObjet.Traitement:=UnAutreObject.UneMethodeCompatible; 
  UnAutreObject.Free; // Je n'en ai plus besoin
  UnObjet.Iteration(tabNom); // **Problème, la méthode de l'objet référencé n'est plus accessible

Si la méthode UneMethodeCompatible utilise des variables propres à UnAutreObject il ne faut pas le détruire tant que UnObjet.Traitement référence une de ces méthodes.

Jusqu'à maintenant ces deux approches ne différent pas fonctionnellement.

Il peut être intéressant de pouvoir manipuler indistinctement ces deux types.

IV-A. Appel d'une méthode en lieu et place d'une procédure▲

Enumere(tabNom, UnObjet.Affiche);

Erreur E2009 : Types incompatibles : 'procédure normale et pointeur de méthode'

type
  TMethod = record
   Code, 
   Data : Pointer;
  end;

  TMethod = record
  public
    var
      Data: TObject;
      Code: TMethodCode; //MemberInfo

    // TODO: We should be able to support ClassVar.Methods and ClassStatic.Methods as well
    constructor Create(AData: TObject; ACode: TMethodCode); overload;
    constructor Create(AData: TObject; const AName: string); overload;
    function Clone: TMethod;

    function CanInvoke: Boolean;
    function Invoke(const AParams: array of TObject): TObject;
    function ToString: string; override;

    function IsEmpty: Boolean;
    class function Empty: TMethod; static;

    class operator Implicit(ADelegate: Delegate): TMethod;
    class operator Equal(const ALeft, ARight: TMethod): Boolean;
    class operator NotEqual(const ALeft, ARight: TMethod): Boolean;
  end;

var MaMethod : TMethod;
     MaProc   : TProcedureTypee;

  MaMethod:=TMethod(UnObjet.Traitement);
  MaProc:=MaMethod.Code;
  Enumere(tabNom,MaProc);

TProcedureTypeeModifiee = Procedure(ParametreVide:Pointer; Element : String);

procedure EnumereV2(Collection: TStringDynArray ; Traitement:TProcedureTypeeModifiee);
var  I       : Integer;
begin
  for i := Low(Collection) to High(Collection) do
   Traitement(Nil,Collection[i]);
end;

  EnumereV2(tabNom,@TUneClasse.Affiche);

var MaProcV2 : TProcedureTypeeModifiee;
...
  MaMethod:=TMethod(UnObjet.Traitement); // Peut pointer sur une méthode virtuelle
  MaProcV2:=MaMethod.Code;
  EnumereV2(tabNom,MaProcV2);

TUneClasse =Class
 private
  FProcedure : TProcedureObjet;
 public
  class procédure clsAffiche(Element: String);
  ...

  EnumereV2(tabNom,@TUneClasse.clsAffiche);

IV-B. Appel d'une procédure en lieu et place d'une méthode▲

Function MakeProcedureOfObject(ProcedureCible : Pointer):TMethod;
//Construit un record TMethod avec l'adresse d'une procédure classique
begin
 Result.code:=ProcedureCible; //L'adresse de la procédure à appeler
 Result.Data:=Nil;  //L'objet est inconnu dans ce cas.
end;

UnObjet.Traitement:=TProcedureObjet(MakeProcedureOfObject(@AfficheTableau2));
 UnObjet.Iteration(tabNom);

Bien évidemment ce que l'on vient de voir ici n'est pas très orthodoxe comme approche, mais peut dans certaines circonstances être utile au moins pour la seconde pratique. Je vous laisse seul juge de tels usages.
Sachez enfin que pour la manipulation de hook, ou appel callback, Delphi propose la méthode Classes.MakeObjectInstance qui se charge de convertir un type particulier de méthode d'objet en un pointeur. Vous pouvez consulter le code source de la VCL ou ce lien ;-)

Une autre approche pour le callback, une autre avec de l'assembleur (code à vérifier).

Je vous recommande sur le sujet, mais dans une autre catégorie, la lecture de ce tutoriel très pointu nommé Construire une procédure pointant sur une méthode, écrit et conçu par Sébastien Doeraene.