检索F#函数的MethodInfo [英] Retrieve MethodInfo of a F# function

问题描述

我想编写一个将函数f作为参数并返回与f相关联的System.Reflection.MethodInfo的函数.

I would like to write a function that takes a function f as an argument and returns the System.Reflection.MethodInfo associated to f.

我不太确定这是否可行.

I'm not quite sure if it is feasible or not.

推荐答案

因此，我终于找到了解决方案.很hacky，但是嘿！有用！ (仅在调试"模式下).

So, I finally found a solution. Very hacky, but hey! It works! (edit: in Debug mode only).

let Foo (f:S -> A[] -> B[] -> C[] -> D[] -> unit) =
    let ty     = f.GetType()
    let argty  = [|typeof<S>; typeof<A[]>; typeof<B[]>; typeof<C[]>;typeof<D[]>|]
    let mi     = ty.GetMethod("Invoke", argty)
    let il     = mi.GetMethodBody().GetILAsByteArray()
    let offset = 9//mi.GetMethodBody().MaxStackSize

    let token  = System.BitConverter.ToInt32(il, offset)    
    let mb     = ty.Module.ResolveMethod(token)

    match Expr.TryGetReflectedDefinition mb with
    | Some ex -> printfn "success %A" e
    | None ->  failwith "failed"

即使f是在另一个程序集(.dll)中定义的，也可以在Foo调用的同一位置定义，它仍然可以正常工作. 由于我必须定义什么是argty，所以还不是很全面，但是我敢肯定我可以编写一个实现该功能的函数.

It works well, even if f is defined in another assembly (.dll) or in the same where the call of Foo happens. It's not fully general yet since I have to define what argty is, but I'm sure I can write a function that does it.

在编写此代码后发现，尽管在C#中，Dustin对于相同的问题也有类似的解决方案(请参见

Turns out after writing this code that Dustin have a similar solution for the same issue, albeit in C# (see it here).

所以这是一个用法示例:

So here's an usage example:

open System
open Microsoft.FSharp.Quotations

[<ReflectedDefinition>]
let F (sv:int) (a:int[]) (b:int[]) (c:int[]) (d:int[]) =
    let temp = a.[2] + b.[3]
    c.[0] <- temp
    ()

let Foo (f:S -> A[] -> B[] -> C[] -> D[] -> unit) =
    let ty     = f.GetType()
    let arr    = ty.BaseType.GetGenericArguments()
    let argty  = Array.init (arr.Length-1) (fun i -> arr.[i])

    let mi     = ty.GetMethod("Invoke", argty)
    let il     = mi.GetMethodBody().GetILAsByteArray()
    let offset = 9
    let token  = System.BitConverter.ToInt32(il, offset)
    let mb     = ty.Module.ResolveMethod(token)
    mb

let main () =
  let mb = Foo F
  printfn "%s" mb.Name

  match Expr.TryGetReflectedDefinition mb with
  | None -> ()
  | Some(e) -> printfn "%A" e

do main ()

它的作用是打印F的名称，如果功能是反映的定义，则打印它的AST.

What it does is printing name of F, and its AST if the function is a reflected definition.

但是经过进一步调查后，发现此hack仅在调试模式下有效(并且F必须是函数值以及顶级定义)，因此也可以说这是不可能要做的事情.

But after further investigation, it happens that this hack only works in debug mode (and F has to be a function value as well as a top level definition), so might as well say that it's an impossible thing to do.

这是调试/发布版本中FSharpFunc的Invoke方法的IL代码:

Here's the IL code of the FSharpFunc's Invoke method in both debug/release build:

调试模式:

.method /*06000007*/ public strict virtual 
        instance class [FSharp.Core/*23000002*/]Microsoft.FSharp.Core.Unit/*01000006*/ 
        Invoke(int32 sv,
               int32[] a,
               int32[] b,
               int32[] c,
               int32[] d) cil managed
// SIG: 20 05 12 19 08 1D 08 1D 08 1D 08 1D 08
{
  // Method begins at RVA 0x21e4
  // Code size       16 (0x10)
  .maxstack  9
  IL_0000:  /* 00   |                  */ nop
  IL_0001:  /* 03   |                  */ ldarg.1
  IL_0002:  /* 04   |                  */ ldarg.2
  IL_0003:  /* 05   |                  */ ldarg.3
  IL_0004:  /* 0E   | 04               */ ldarg.s    c
  IL_0006:  /* 0E   | 05               */ ldarg.s    d
  IL_0008:  /* 28   | [phone]       */ call       void Program/*02000002*/::F(int32,
                                                                                 int32[],
                                                                                 int32[],
                                                                                 int32[],
                                                                                 int32[]) /* 06000001 */
  IL_000d:  /* 00   |                  */ nop
  IL_000e:  /* 14   |                  */ ldnull
  IL_000f:  /* 2A   |                  */ ret
} // end of method mb@25::Invoke

释放模式:

method public strict virtual instance class [FSharp.Core]Microsoft.FSharp.Core.Unit 
        Invoke(int32 sv,
               int32[] a,
               int32[] b,
               int32[] c,
               int32[] d) cil managed
{
  // Code size       28 (0x1c)
  .maxstack  7
  .locals init ([0] int32 V_0)
  IL_0000:  nop
  IL_0001:  ldarg.2
  IL_0002:  ldc.i4.2
  IL_0003:  ldelem     [mscorlib]System.Int32
  IL_0008:  ldarg.3
  IL_0009:  ldc.i4.3
  IL_000a:  ldelem     [mscorlib]System.Int32
  IL_000f:  add
  IL_0010:  stloc.0
  IL_0011:  ldarg.s    c
  IL_0013:  ldc.i4.0
  IL_0014:  ldloc.0
  IL_0015:  stelem     [mscorlib]System.Int32
  IL_001a:  ldnull
  IL_001b:  ret
} // end of method mb@25::Invoke

您可以看到在释放模式下，编译器将F的代码内联到Invoke方法中，因此调用F的信息(以及检索令牌的可能性)消失了..

You can see that in release mode, the compiler inlines code of F into the Invoke method, so the information of calling F (and the possibility to retrieve the token) is gone..

这篇关于检索F#函数的MethodInfo的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！