Delegáti (F#)
Delegát představuje volání funkce jako objekt.V F# obvykle pomocí funkce hodnoty představují funkce jako prvotřídní hodnoty; Delegáti se používají v.NET Framework a tak jsou potřebné při spolupracovat s rozhraní API, která je očekávali.Mohou být použity také při vytváření knihovny navržený pro použití jiných.NET Framework jazyky.
type delegate-typename = delegate of type1 -> type2
Poznámky
V syntaxi předchozí type1 představuje argument typ nebo typy a type2 představuje návratového typu.Typy argumentů, které jsou reprezentovány type1 automaticky curried.To naznačuje, že pro tento typ použití formuláře n-tice, pokud jsou argumenty funkce cílové curried a n-tice v závorce u argumentů, které jsou již ve formuláři n-tice.Automatické currying odebere sadu závorky, ponechat argument n-tice, který odpovídá cílové metodě.Naleznete příklad kódu pro syntaxi, kterou byste měli použít v každém případě.
Delegáti instance metody nebo může být připojena F# funkce hodnoty a statický.F# funkce hodnoty lze předat přímo jako argumenty delegování konstruktory.Statické metody pomocí názvu třídy a metody konstrukce delegáta.Pro metodu instance poskytují instanci objektu a metody v jeden argument.V obou případech člen přístup operátora (.) se používá.
Invoke Na typ delegáta metoda volá funkci zapouzdřený.Delegáti mohou být také předány jako hodnoty funkce odkazem na název metody Invoke bez závorek.
Následující kód ukazuje syntaxi pro vytváření delegátů, které představují různé metody ve třídě.V závislosti na tom, zda je metoda statická metoda nebo metody instance a zda má argumenty ve formuláři curried nebo n-tice syntaxe pro deklarování a přiřazování delegát se trochu liší.
type Test1() =
static member add(a : int, b : int) =
a + b
static member add2 (a : int) (b : int) =
a + b
member x.Add(a : int, b : int) =
a + b
member x.Add2 (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( Test1.add )
let del2 : Delegate2 = new Delegate2( Test1.add2 )
let testObject = Test1()
// For instance methods, use the instance value name, the dot operator, and the instance method name.
let del3 : Delegate1 = new Delegate1( testObject.Add )
let del4 : Delegate2 = new Delegate2( testObject.Add2 )
for (a, b) in [ (100, 200); (10, 20) ] 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)
Následující kód ukazuje různé způsoby práce s delegáty.
type Delegate1 = delegate of int * char -> string
let replicate n c = String.replicate n (string c)
// An F# function value constructed from an unapplied let-bound function
let function1 = replicate
// A delegate object constructed from an F# function value
let delObject = new Delegate1(function1)
// An F# function value constructed from an unapplied .NET member
let functionValue = delObject.Invoke
List.map (fun c -> functionValue(5,c)) ['a'; 'b'; 'c']
|> List.iter (printfn "%s")
// Or if you want to get back the same curried signature
let replicate' n c = delObject.Invoke(n,c)
// You can pass a lambda expression as an argument to a function expecting a compatible delegate type
// System.Array.ConvertAll takes an array and a converter delegate that transforms an element from
// one type to another according to a specified function.
let stringArray = System.Array.ConvertAll([|'a';'b'|], fun c -> replicate' 3 c)
printfn "%A" stringArray
Výstup předchozího příkladu kódu je následující.
aaaaa
bbbbb
ccccc
[|"aaa"; "bbb"|]