F # - Delegierte

Ein Delegat ist eine Referenztypvariable, die den Verweis auf eine Methode enthält. Die Referenz kann zur Laufzeit geändert werden. F # -Delegierte ähneln Zeigern auf Funktionen in C oder C ++.

Delegierte erklären

Die Delegatendeklaration bestimmt die Methoden, auf die der Delegat verweisen kann. Ein Delegat kann auf eine Methode verweisen, die dieselbe Signatur wie die des Delegaten hat.

Die Syntax für die Delegatendeklaration lautet -

type delegate-typename = delegate of type1 -> type2

Betrachten Sie zum Beispiel die Delegierten -

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

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

Sowohl die Delegierten können verwendet werden , um eine Methode zu verweisen , die zwei hat int Parameter und gibt einen int Typ Variable.

In der Syntax -

type1 repräsentiert den / die Argumenttyp (e).
type2 repräsentiert den Rückgabetyp.

Bitte beachten Sie -

Die Argumenttypen werden automatisch überprüft.
Delegaten können an Funktionswerte sowie statische oder Instanzmethoden angehängt werden.
F # -Funktionswerte können direkt als Argumente an delegierte Konstruktoren übergeben werden.
Bei einer statischen Methode wird der Delegat unter Verwendung des Namens der Klasse und der Methode aufgerufen. Für eine Instanzmethode wird der Name der Objektinstanz und -methode verwendet.
Die Invoke-Methode für den Delegatentyp ruft die gekapselte Funktion auf.
Delegaten können auch als Funktionswerte übergeben werden, indem auf den Namen der Invoke-Methode ohne Klammern verwiesen wird.

Das folgende Beispiel zeigt das Konzept -

Beispiel

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)

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

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