Méthodes anonymes dans Object Pascal

De Appmethod Topics
Aller à : navigation, rechercher

Remonter à Procédures et fonctions - Index

Comme le nom le suggère, une méthode anonyme est une procédure ou une fonction n'ayant pas de nom associé. Une méthode anonyme traite un bloc de code comme une entité qui peut être affectée à une variable ou utilisée comme paramètre d'une méthode. En outre, une méthode anonyme peut faire référence aux variables et lier des valeurs aux variables dans le contexte dans lequel la méthode a été définie. Les méthodes anonymes peuvent être définies et utilisées avec une syntaxe simple. Elles sont similaires à la construction de closures définis dans d'autres langages.

Syntaxe

Une méthode anonyme est définie de la même façon qu'une procédure ou une fonction normale, mais sans nom. Par exemple, cette fonction renvoie une fonction qui est définie comme méthode anonyme :


function MakeAdder(y: Integer): TFuncOfInt;
begin
Result := { démarre la méthode anonyme } function(x: Integer) : Integer
  begin
    Result := x + y;
    end; { termine la méthode anonyme }
end;

La fonction MakeAdder renvoie une fonction qu'il déclare sans nom : une méthode anonyme.

Notez que MakeAdder renvoie une valeur de type TFuncOfInt. Un type méthode anonyme est déclaré comme référence à une méthode :

type
  TFuncOfInt = reference to function(x: Integer): Integer;

Cette déclaration indique que la méthode anonyme--

  • est une fonction
  • prend un paramètre integer
  • renvoie une valeur integer.

En général, un type fonction anonyme est déclaré pour une procédure ou une fonction :

type
  TType1 = reference to procedure[(parameterlist)];
  TType2 = reference to function[(parameterlist)]: returntype;

Voici deux exemples de types :


type
  TSimpleProcedure = reference to procedure;
  TSimpleFunction = reference to function(x: string): Integer;

Une méthode anonyme est déclarée comme une procédure ou une fonction sans nom :


// Procédure
procedure[(paramètres)]
begin
  { bloc d'instructions }
end;
// Fonction
function[(paramètres)]: returntype
begin
  { bloc d'instructions }
end;

Utilisation des méthodes anonymes

Les méthodes anonymes sont typiquement affectées à quelque chose, comme dans ces exemples :


myFunc := function(x: Integer): string
begin
  Result := IntToStr(x);
end;

myProc := procedure(x: Integer)
begin
  Writeln(x);
end;

Les méthodes anonymes peuvent également être renvoyées par des fonctions ou passées comme valeurs de paramètres lors de l'appel de méthodes. Par exemple, avec la variable de méthode anonyme myFunc définie juste devant :


type
  TFuncOfIntToString = reference to function(x: Integer): string;

procedure AnalyzeFunction(proc: TFuncOfIntToString);
begin
  { du code }
end;

// Appel d'une procédure avec une méthode anonyme en paramètre
// Utilisation de la variable :
AnalyzeFunction(myFunc);

// Utiliser directement la méthode anonyme :
AnalyzeFunction(function(x: Integer): string
begin
  Result := IntToStr(x);
end;)

Les références de méthode peuvent également être affectées aux méthodes ainsi qu'aux méthodes anonymes. Par exemple :


type
  TMethRef = reference to procedure(x: Integer);
TMyClass = class
  procedure Method(x: Integer);
end;

var
  m: TMethRef;
  i: TMyClass;
begin
  // ...
  m := i.Method;   // affectation à la référence de méthode
end;

Toutefois, la réciproque n'est pas vraie : vous ne pouvez pas affecter une méthode anonyme à un pointeur de méthode normal. Les références de méthode sont des types managés, mais les pointeurs de méthode sont des types non managés. Ainsi, pour des raisons de fiabilité des types, l'affectation de références de méthode à des pointeurs de méthode n'est pas supportée. Par exemple, les événements sont des propriétés de méthode évaluées en pointeur , vous ne pouvez donc pas utiliser une méthode anonyme pour un événement. Pour de plus amples informations sur cette restriction, voir la section relative à la liaison des variables.

Liaison des variables des méthodes anonymes

Une fonctionnalité clé des méthodes anonymes est qu'elles peuvent référencer des variables qui leur sont visibles là où elles ont été définies. En outre, ces variables peuvent être liées à des valeurs et encapsulées avec une référence à la méthode anonyme. Cela capture l'état et étend la durée de vie des variables.

Illustration de la liaison des variables

Considérons de nouveau la fonction définie ci-dessus :


function MakeAdder(y: Integer): TFuncOfInt; 
begin
  Result := function(x: Integer) : Integer
  begin
    Result := x + y;
  end;
end;

Vous pouvez créer une instance de cette fonction qui lie une valeur de variable :

var
  adder: TFuncOfInt;
begin
  adder := MakeAdder(20);
  Writeln(adder(22)); // prints 42
end.

La variable adder contient une méthode anonyme qui lie la valeur 20 à la variable y référencée dans le bloc de code de la méthode anonyme. Cette liaison persiste même si la valeur sort de la portée.

Méthodes anonymes en tant qu'événements

Une motivation pour l'utilisation des références de méthode est d'avoir un type pouvant contenir des variables liées, également connues en tant que valeurs closure. Puisque les closures se ferment sur leur environnement de définition, incluant toutes les variables locales référencées au point de définition, ils ont un état qui doit être libéré. Comme les références de méthode sont des types managés (références comptées), elles peuvent conserver la trace de cet état et le libérer quand cela est nécessaire. Si une référence de méthode ou un closure peut être affecté librement à un pointeur de méthode, tel qu'un événement, il est alors facile de créer des programmes mal formés avec des pointeurs incorrects ou des pertes de mémoire.

Les événements Object Pascal sont une convention pour les propriétés. Il n'a pas de différence entre un événement et une propriété, à l'exception du type. Si une propriété est de type pointeur de méthode, c'est alors un événement.

Si une propriété est de type référence de méthode, elle devrait être aussi logiquement considérée comme un événement. Toutefois, l'EDI ne la traite pas comme un événement. C'est important pour les classes qui sont installées dans l'EDI, comme les composants et les contrôles personnalisés.

Par conséquent, pour avoir un événement sur un composant ou un contrôle personnalisé qui peut être assigné à l'aide d'une référence de méthode ou d'une valeur closure, la propriété doit être de type référence de méthode. Toutefois, c'est peu pratique car l'EDI ne la reconnaît pas comme un événement.

Voici un exemple d'utilisation d'une propriété avec un type référence de méthode, afin qu'elle puisse opérer comme un événement :


type
  TProc = reference to procedure;
  TMyComponent = class(TComponent)
  private
    FMyEvent: TProc;
  public
    // La propriété MyEvent agit comme un événement :
    property MyEvent: TProc read FMyEvent write FMyEvent;
    // un autre code invoque FMyEvent comme un pattern habituel pour les événements
  end;

...

var
  c: TMyComponent;
begin
  c := TMyComponent.Create(Self);
  c.MyEvent := procedure
  begin
    ShowMessage('Hello World!'); // montre quand TMyComponent invoque MyEvent
  end;
end;

Mécanisme de liaison des variables

Pour éviter la création de pertes de mémoire, il est utile de bien comprendre le processus de liaison des variables.

Les variables locales définies au début d'une procédure, fonction ou méthode (ci-après une "routine") vivent normalement tant que la routine est active. Les méthodes anonymes peuvent étendre la durée de vie de ces variables.

Si une méthode anonyme fait référence à une variable locale externe dans son corps, cette variable est "capturée". La capture signifie l'extension de la durée de vie de la variable, afin qu'elle puisse vivre aussi longtemps que la valeur de la méthode anonyme, plutôt que de mourir avec sa routine de déclaration. Notez que cette capture de variable capture les variables, et pas les valeurs. Si la valeur d'une variable change après sa capture par construction d'une méthode anonyme, la valeur de la variable que la méthode anonyme a capturé change aussi, car il s'agit de la même variable avec le même stockage. Les variables capturées sont stockées sur le tas, pas dans la pile.

Les valeurs de la méthode anonyme sont de type référence de méthode, et les références sont comptées. Quand la dernière référence de méthode à une valeur de méthode anonyme donnée sort de la portée, est effacée (initialisée à nil) ou finalisée, les variables capturées sortent de la portée.

Cette situation est plus compliquée dans le cas où plusieurs méthodes anonymes capturent la même variable locale. Pour comprendre comment cela fonctionne dans toutes les situations, il est nécessaire d'être plus précis sur le processus d'implémentation.

A chaque fois qu'une variable locale est capturée, elle est ajoutée à un "objet cadre" associé à sa routine de déclaration. Chaque méthode anonyme déclarée dans une routine est convertie en une méthode de l'objet cadre associé à sa routine conteneur. Enfin, tout objet cadre créé à la suite de la construction d'une valeur de méthode anonyme ou de la capture d'une variable est chaîné à son cadre parent par une autre référence, si un tel cadre existe et s'il est nécessaire d'accéder à une variable externe capturée. Ces liens d'un objet cadre à son cadre parent sont également comptabilisés par références. Une méthode anonyme déclarée dans une routine locale imbriquée qui capture les variables de sa routine parent conserve cet objet cadre parent en vie tant qu'elle ne sort pas elle-même de la portée.

Considérons, par exemple, la situation suivante :


type
  TProc = reference to procedure;
procedure Call(proc: TProc);
// ...
procedure Use(x: Integer);
// ...

procedure L1; // frame F1
var
  v1: Integer;

  procedure L2; // cadre F1_1
  begin
    Call(procedure // cadre F1_1_1
    begin
      Use(v1);
    end);
  end;

begin
  Call(procedure // cadre F1_2
  var
    v2: Integer;
  begin
    Use(v1);
    Call(procedure // cadre F1_2_1
    begin
      Use(v2);
    end);
  end);
end;

Chaque routine et méthode anonyme est annotée d'un identificateur de cadre permettant de faciliter l'identification des liens d'objets cadre :

  • v1 est une variable dans F1
  • v2 est une variable dans F1_2 (capturé par F1_2_1)
  • la méthode anonyme pour F1_1_1 est une méthode dans F1_1
  • F1_1 est lié à F1 (F1_1_1 utilise v1)
  • la méthode anonyme pour F1_2 est une méthode dans F1
  • la méthode anonyme pour F1_2_1 est une méthode dans F1_2

Les cadres F1_2_1 et F1_1_1 ne requièrent pas des objets cadre, puisqu'ils ne déclarent pas de méthodes anonymes, ni ne contiennent des variables qui sont capturées. Ils ne sont pas sur un chemin de parentage entre une méthode anonyme incorporée et une variable capturée externe. Ils ont des cadres implicites stockés sur la pile.

Avec seulement une référence à la méthode anonyme F1_2_1, les variables v1 et v2 sont gardées en vie. Si à la place, la seule référence qui survit à l'invocation de F1 est F1_1_1, seule la variable v1 est gardée en vie.

Il est possible de créer un cycle dans les chaînes de liens cadre/référence de méthode qui provoque une perte de mémoire. Par exemple, le stockage d'une méthode anonyme directement ou indirectement dans une variable, que la méthode anonyme elle-même capture, crée un cycle, ce qui provoque une perte de mémoire.

Utilité des méthodes anonymes

Les méthodes anonymes offrent plus qu'un simple pointeur sur quelque chose qui peut être appelé. Elles offrent plusieurs avantages :

  • la liaison des valeurs des variables
  • un moyen facile de définir et d'utiliser les méthodes
  • un paramétrage facile à l'aide du code

Liaison des variables

Les méthodes anonymes fournissent un bloc de code avec des liaisons de variables à l'environnement dans lequel elles sont définies, même si cet environnement n'est pas dans la portée. Un pointeur sur une fonction ou une procédure ne peut pas faire cela.

Par exemple, l'instruction adder := MakeAdder(20); de l'exemple de code ci-dessus produit une variable adder qui encapsule la liaison d'une variable à la valeur 20.

Certains autres langages qui implémentent une telle construction y font référence en tant que closures. Historiquement, l'idée était que l'évaluation d'une expression comme adder := MakeAdder(20); produisait un closure. Elle représente un objet qui contient des références aux liaisons de toutes les variables référencées dans la fonction et définies en dehors, le fermant ainsi en capturant les valeurs des variables.

Utilisation facile

L'exemple suivant montre une définition de classe typique permettant de définir quelques méthodes simples, puis de les invoquer :


type
  TMethodPointer = procedure of object; // déléguer void TMethodPointer();
  TStringToInt = function(x: string): Integer of object;

TObj = class
  procedure HelloWorld;
  function GetLength(x: string): Integer;
end;

procedure TObj.HelloWorld;
  begin
    Writeln('Hello World');
  end;

function TObj.GetLength(x: string): Integer;
begin
  Result := Length(x);
end;

var
  x: TMethodPointer;
  y: TStringToInt;
  obj: TObj;

begin
  obj := TObj.Create;

  x := obj.HelloWorld;
  x;
  y := obj.GetLength;
  Writeln(y('foo'));
end.

Différent des mêmes méthodes définies et invoquées à l'aide des méthodes anonymes :


type
  TSimpleProcedure = reference to procedure;
  TSimpleFunction = reference to function(x: string): Integer;

var
  x1: TSimpleProcedure;
  y1: TSimpleFunction;

begin
  x1 := procedure
    begin
      Writeln('Hello World');
    end;
  x1;   //invoque la méthode anonyme qui vient d'être définie

  y1 := function(x: string): Integer
    begin
      Result := Length(x);
    end;
  Writeln(y1('bar'));
end.

Notez que le code qui utilise les méthodes anonymes est plus simple et plus court. Cela est idéal si vous voulez définir explicitement et simplement ces méthodes et les utiliser immédiatement sans effort supplémentaire de création d'une classe qui pourrait ne jamais servir ailleurs. Le code résultant est plus facile à comprendre.

Utilisation du code pour un paramètre

Les méthodes anonymes rendent plus faciles l'écriture des fonctions et des structures paramétrées par code (pas seulement les valeurs).

La gestion multithread est une bonne application pour les méthodes anonymes. Si vous voulez exécuter du code en parallèle, vous pourriez avoir une fonction ParallelFor ressemblant à ceci :

type
  TProcOfInteger = reference to procedure(x: Integer);

procedure ParallelFor(start, finish: Integer; proc: TProcOfInteger);

La procédure ParallelFor passe en revue les différents threads d'une procédure. En supposant que cette procédure est implémentée correctement et de manière efficace à l'aide de threads ou d'un pool de threads, elle pourrait alors être facilement utilisée pour tirer profit des processeurs multiples :

procedure CalculateExpensiveThings;
var
  results: array of Integer;
begin
  SetLength(results, 100);
  ParallelFor(Low(results), High(results),
    procedure(i: Integer)                           // \
    begin                                           //  \ bloc de code
      results[i] := ExpensiveCalculation(i);        //  /  utilisé comme paramètre
    end                                             // /
    );
  // utiliser les résultats
  end;

Contrastez cela avec la façon de faire sans les méthodes anonymes : probablement une classe "tâche" avec une méthode abstraite virtuelle, un descendant concret pour ExpensiveCalculation, puis en ajoutant toutes les tâches à une file d'attente.

Ici, l'algorithme "parallel-for" est l'abstraction qui est paramétrée par code. Auparavant, un moyen commun d'implémenter ce pattern incluait une classe de base virtuelle avec une ou plusieurs méthodes abstraites ; considérez la classe TThread et sa méthode abstraite Execute. En revanche, les méthodes anonymes rendent ce pattern, paramétrage des algorithmes et des structures de données, plus facile.