通过

委托 (F#)

  • 项目

委托将函数调用表示为对象。 在 F# 中，通常应使用函数值将函数表示为第一类值；但是，在 .NET Framework 中使用委托，所以在与预期要使用委托的 API 进行互操作时需要使用它们。 为创作旨在通过其他 .NET Framework 语言使用的库时也可以使用它们。

语法

type delegate-typename = delegate of type1 -> type2

备注

在前面的语法中，type1 表示参数类型或类型，type2 表示返回类型。 type1 所表示的参数类型会自动扩充。 这表明，对于此类型，如果目标函数采用扩充参数，则使用元组形式，并为已为元组形式的参数使用带圆括号的元组。 自动扩充将删除一组括号，并保留与目标方法匹配的元组参数。 若要了解应在各种情况下使用的语法，请参阅代码示例。

委托可以附加到 F# 函数值、静态方法或实例方法。 F# 函数值可以作为参数直接传递至委托构造函数。 对于静态方法，可以使用类的名称和方法构造委托。 对于实例方法，请在一个参数中提供对象实例和方法。 在这两种情况下，都使用成员访问运算符 (.)。

委托类型上的 Invoke 方法调用封装的函数。 此外，可以通过引用调用方法名称（不带括号）将委托作为函数值进行传递。

下面的代码演示了用于创建委托的语法，表示类中的各种方法。 声明和分配委托的语法会略有不同，具体取决于该方法是静态方法还是实例方法，以及它是否具有元组形式或扩充形式的参数。

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)

下面的代码演示了一些可以使用委托的不同方式。

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

上一个代码示例的输出如下所示。

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

可以通过如下所示的方式将名称添加到委托参数：

// http://www.pinvoke.net/default.aspx/user32/WinEventDelegate.html
type WinEventDelegate = delegate of hWinEventHook:nativeint * eventType:uint32 * hWnd:nativeint * idObject:int * idChild:int * dwEventThread:uint32 * dwmsEventTime:uint32 -> unit

委托参数名称是可选的，将在 Invoke 方法中显示。 它们不需要与实现中的参数名称相匹配。 它们只允许使用柯里化形式，但不允许使用元组形式。

type D1 = delegate of item1: int * item2: string -> unit
let a = D1(fun a b -> printf "%s" b)
a.Invoke(item2 = "a", item1 = 1) // Calling with named arguments

type D2 = delegate of int * item2: string -> unit // Omitting one name
let b = D2(fun a b -> printf "%s" b)
b.Invoke(1, item2 = "a")

上一个代码示例的输出如下所示。

aa

另请参阅