如何将System.Reflection.MemberInfo值转换为它表示的F＃值？

Question

I'm trying to load and execute F# code at runtime. The FSharp.Compiler.Service assembly produces System.Reflection.MemberInfo values for each value (or function) definition in a program.

I'm roughly trying to implement the following:

cast<'a> : System.Reflection.MemberInfo -> 'a

Which succeeds if the MemberInfo value represents a value of type 'a (and returns that value), or fails otherwise.

Answer 1

First, your function will need to have an optional result - to indicate that it might not always succeed.

Then, members could be (a) nested types, (b) properties, (c) fields, and (d) methods. I'm guessing you're only interested in the latter three.

You will need to handle these three cases separately, because they are actually different things, not three kinds of the same thing. For fields and properties, you can use FieldInfo.GetValue and PropertyInfo.GetValue respectively to obtain the value. For methods, you can use MethodInfo.Invoke to call it and return the result.

Roughly:

let getValue<'a> (o: obj) (m: MemberInfo): 'a option =
  match m with
  | :? FieldInfo as f when f.FieldType = typeof<'a> -> 
    Some( f.GetValue o :?> 'a )
  | :? PropertyInfo as p when p.PropertyType = typeof<'a> && p.GetIndexParameters().Length = 0 -> 
    Some( p.GetValue( o, [||] ) :?> 'a )
  | _ -> None

let getFunc<'a, 'b> (o: obj) (m: MemberInfo): ('a -> 'b) option =
  match m with
  // F# compiler may compile some functions as properties of type FSharpFunc<_>, so need to cover that
  | :? FieldInfo -> getValue<'a -> 'b> o m
  | :? PropertyInfo -> getValue<'a -> 'b> o m

  // If it's a real method of the right type, create a closure to call it
  | :? MethodInfo as mt 
    when mt.ReturnType = typeof<'b> && 
         mt.GetParameters().Length = 1 &&
         mt.GetParameters().[0].ParameterType = typeof<'a> -> 
    Some <| fun (a: 'a) -> mt.Invoke( o, [| a :> obj |] ) :?> 'b

  // Otherwise, can't produce result
  | _ -> None

However, these dynamic invocations would be very slow. From your question, I assume you're trying to do something like a REPL, for which this would be fine, but if you're looking at using this many times, repeatedly, a better way may be to create and compile LINQ Expressions using Expression.MakeMemberAccess for fields/properties and Expression.Call for methods. Don't forget to cache the compiled delegates though, otherwise it would be even slower :-)