Temsilciler (F #)

  • Makale
  • Okumak için 2 dakika

Bir temsilci, bir işlev çağrısını bir nesne olarak temsil eder. F # ' da, işlevleri ilk sınıf değerleri olarak temsil etmek için normalde işlev değerlerini kullanmanız gerekir; ancak, temsilciler .NET Framework kullanılır ve bu nedenle, bunları bekleyen apı 'lerle birlikte çalışırken gereklidir. bunlar ayrıca, diğer .NET Framework dillerden kullanılmak üzere tasarlanan kitaplıkları yazmak için de kullanılabilir.

Syntax

type delegate-typename = delegate of type1 -> type2

Açıklamalar

Önceki sözdiziminde, type1 bağımsız değişken türünü veya türlerini temsil eder ve type2 dönüş türünü temsil eder. Tarafından temsil edilen bağımsız değişken türleri type1 otomatik olarak curried ' dir. Bu, bu tür için hedef işlevin bağımsız değişkenleri curried ise ve başlık formunda zaten olan bağımsız değişkenler için parantez içine alınmış bir tanımlama grubu olan bir demet formu kullanmanızı önerir. Otomatik currying, target yöntemiyle eşleşen bir demet bağımsız değişkeni bırakarak bir parantez kümesini kaldırır. Her durumda kullanmanız gereken sözdiziminin kod örneğine bakın.

Temsilciler F # işlev değerlerine ve statik veya örnek yöntemlerine eklenebilir. F # işlev değerleri doğrudan temsilci oluşturucuları için bağımsız değişken olarak geçirilebilir. Statik bir yöntemde, sınıfının adını ve yöntemini kullanarak temsilciyi oluşturursunuz. Bir örnek yönteminde, nesne örneğini ve yöntemini bir bağımsız değişkende sağlarsınız. Her iki durumda da, üye erişim işleci ( . ) kullanılır.

InvokeTemsilci türündeki yöntemi kapsüllenmiş işlevi çağırır. Ayrıca, temsilciler, parantez olmadan Invoke yöntemi adına başvurarak işlev değerleri olarak geçirilebilir.

Aşağıdaki kod, bir sınıftaki çeşitli yöntemleri temsil eden temsilciler oluşturmak için söz dizimini gösterir. Yöntemin statik bir yöntem veya örnek yöntemi olmasına ve tanımlama grubu formunda veya curried formunda bağımsız değişkenler içerip içermediğini bağlı olarak, temsilciyi bildirme ve atamaya yönelik sözdizimi biraz farklıdır.

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(Test1.add)
let del2 = 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(testObject.Add)
let del4 = 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)

Aşağıdaki kod temsilcilerle çalışabilmeniz için kullanabileceğiniz farklı yolları gösterir.

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 = 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

Önceki kod örneği çıkışı aşağıdaki gibidir.

aaaaa
bbbbb
ccccc
[|"aaa"; "bbb"|]

Ayrıca bkz.