F # - Délégués

Un délégué est une variable de type référence qui contient la référence à une méthode. La référence peut être modifiée lors de l'exécution. Les délégués F # sont similaires aux pointeurs vers des fonctions, en C ou C ++.

Déclarer les délégués

La déclaration de délégué détermine les méthodes qui peuvent être référencées par le délégué. Un délégué peut faire référence à une méthode, qui a la même signature que celle du délégué.

La syntaxe de la déclaration de délégué est -

type delegate-typename = delegate of type1 -> type2

Par exemple, considérez les délégués -

// Delegate1 works with tuple arguments.
type Delegate1 = delegate of (int * int) -> int

// Delegate2 works with curried arguments.
type Delegate2 = delegate of int * int -> int

Les deux délégués peuvent être utilisés pour référencer n'importe quelle méthode qui a deux paramètres int et retourne une variable de type int .

Dans la syntaxe -

  • type1 représente le (s) type (s) d'argument.

  • type2 représente le type de retour.

Veuillez noter -

  • Les types d'arguments sont automatiquement curry.

  • Les délégués peuvent être attachés aux valeurs de fonction et aux méthodes statiques ou d'instance.

  • Les valeurs de la fonction F # peuvent être transmises directement en tant qu'arguments aux constructeurs délégués.

  • Pour une méthode statique, le délégué est appelé à l'aide du nom de la classe et de la méthode. Pour une méthode d'instance, le nom de l'instance d'objet et de la méthode est utilisé.

  • La méthode Invoke sur le type délégué appelle la fonction encapsulée.

  • En outre, les délégués peuvent être passés en tant que valeurs de fonction en référençant le nom de la méthode Invoke sans les parenthèses.

L'exemple suivant illustre le concept -

Exemple

type Myclass() =
   static member add(a : int, b : int) =
      a + b
   static member sub (a : int) (b : int) =
      a - b
   member x.Add(a : int, b : int) =
      a + b
   member x.Sub(a : int) (b : int) =
      a - b

// Delegate1 works with tuple arguments.
type Delegate1 = delegate of (int * int) -> int

// Delegate2 works with curried arguments.
type Delegate2 = delegate of int * int -> int

let InvokeDelegate1 (dlg : Delegate1) (a : int) (b: int) =
   dlg.Invoke(a, b)
let InvokeDelegate2 (dlg : Delegate2) (a : int) (b: int) =
   dlg.Invoke(a, b)

// For static methods, use the class name, the dot operator, and the
// name of the static method.
let del1 : Delegate1 = new Delegate1( Myclass.add )
let del2 : Delegate2 = new Delegate2( Myclass.sub )
let mc = Myclass()

// For instance methods, use the instance value name, the dot operator, 
// and the instance method name.

let del3 : Delegate1 = new Delegate1( mc.Add )
let del4 : Delegate2 = new Delegate2( mc.Sub )

for (a, b) in [ (400, 200); (100, 45) ] do
   printfn "%d + %d = %d" a b (InvokeDelegate1 del1 a b)
   printfn "%d - %d = %d" a b (InvokeDelegate2 del2 a b)
   printfn "%d + %d = %d" a b (InvokeDelegate1 del3 a b)
   printfn "%d - %d = %d" a b (InvokeDelegate2 del4 a b)

Lorsque vous compilez et exécutez le programme, il produit la sortie suivante -

400 + 200 = 600
400 - 200 = 200
400 + 200 = 600
400 - 200 = 200
100 + 45 = 145
100 - 45 = 55
100 + 45 = 145
100 - 45 = 55