F # - Delegados

Un delegado es una variable de tipo de referencia que contiene la referencia a un método. La referencia se puede cambiar en tiempo de ejecución. Los delegados de F # son similares a los punteros a funciones, en C o C ++.

Declarar delegados

La declaración de delegado determina los métodos a los que puede hacer referencia el delegado. Un delegado puede referirse a un método, que tiene la misma firma que la del delegado.

La sintaxis para la declaración de delegado es -

type delegate-typename = delegate of type1 -> type2

Por ejemplo, considere a los delegados:

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

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

Ambos delegados pueden usarse para hacer referencia a cualquier método que tenga dos parámetros int y devuelva una variable de tipo int .

En la sintaxis -

  • type1 representa el (los) tipo (s) de argumento.

  • type2 representa el tipo de retorno.

Tenga en cuenta:

  • Los tipos de argumentos se cursan automáticamente.

  • Los delegados se pueden adjuntar a valores de función y métodos estáticos o de instancia.

  • Los valores de la función F # se pueden pasar directamente como argumentos a los constructores delegados.

  • Para un método estático, se llama al delegado utilizando el nombre de la clase y el método. Para un método de instancia, se utiliza el nombre de la instancia y el método del objeto.

  • El método Invoke en el tipo de delegado llama a la función encapsulada.

  • Además, los delegados se pueden pasar como valores de función haciendo referencia al nombre del método Invoke sin los paréntesis.

El siguiente ejemplo demuestra el concepto:

Ejemplo

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)

Cuando compila y ejecuta el programa, produce el siguiente resultado:

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