F # - Delegados

Um delegado é uma variável de tipo de referência que contém a referência a um método. A referência pode ser alterada em tempo de execução. Os delegados F # são semelhantes a ponteiros para funções, em C ou C ++.

Delegados Declarantes

A declaração de delegado determina os métodos que podem ser referenciados pelo delegado. Um delegado pode referir-se a um método, que possui a mesma assinatura do delegado.

A sintaxe para declaração de delegado é -

type delegate-typename = delegate of type1 -> type2

Por exemplo, considere os 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 os delegados podem ser usados para fazer referência a qualquer método que tenha dois parâmetros int e retorna uma variável do tipo int .

Na sintaxe -

type1 representa o (s) tipo (s) de argumento.
type2 representa o tipo de retorno.

Observe -

Os tipos de argumento são curry automaticamente.
Os delegados podem ser anexados a valores de função e métodos estáticos ou de instância.
Os valores da função F # podem ser passados diretamente como argumentos para delegar construtores.
Para um método estático, o delegado é chamado usando o nome da classe e o método. Para um método de instância, o nome da instância do objeto e método é usado.
O método Invoke no tipo delegado chama a função encapsulada.
Além disso, delegados podem ser passados como valores de função fazendo referência ao nome do método Invoke sem os parênteses.

O exemplo a seguir demonstra o conceito -

Exemplo

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 você compila e executa o programa, ele produz a seguinte saída -

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