F # - Delegati

Un delegato è una variabile del tipo di riferimento che contiene il riferimento a un metodo. Il riferimento può essere modificato in fase di esecuzione. I delegati F # sono simili ai puntatori alle funzioni, in C o C ++.

Dichiarare i delegati

La dichiarazione del delegato determina i metodi a cui può fare riferimento il delegato. Un delegato può fare riferimento a un metodo, che ha la stessa firma di quella del delegato.

La sintassi per la dichiarazione del delegato è:

type delegate-typename = delegate of type1 -> type2

Ad esempio, considera i delegati:

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

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

Entrambi i delegati possono essere utilizzati per fare riferimento a qualsiasi metodo che abbia due parametri int e restituisca una variabile di tipo int .

Nella sintassi -

  • type1 rappresenta i tipi di argomenti.

  • type2 rappresenta il tipo restituito.

Nota:

  • I tipi di argomenti vengono automaticamente curati.

  • I delegati possono essere associati a valori di funzione e metodi statici o di istanza.

  • I valori della funzione F # possono essere passati direttamente come argomenti ai costruttori delegati.

  • Per un metodo statico, il delegato viene chiamato utilizzando il nome della classe e il metodo. Per un metodo di istanza, viene utilizzato il nome dell'istanza di oggetto e del metodo.

  • Il metodo Invoke sul tipo delegato chiama la funzione incapsulata.

  • Inoltre, i delegati possono essere passati come valori di funzione facendo riferimento al nome del metodo Invoke senza parentesi.

Il seguente esempio dimostra il concetto:

Esempio

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)

Quando compili ed esegui il programma, restituisce il seguente output:

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