Can you get a Func<T> (or similar) from a MethodInfo object?

Question

I realize that, generally speaking, there are performance implications of using reflection. (I myself am not a fan of reflection at all, actually; this is a purely academic question.)

Suppose there exists some class that looks like this:

public class MyClass {     public string GetName() {         return "My Name";     } } 

Bear with me here. I know that if I have an instance of MyClass called x, I can call x.GetName(). Furthermore, I could set a Func<string> variable to x.GetName.

Now here's my question. Let's say I don't know the above class is called MyClass; I've got some object, x, but I have no idea what it is. I could check to see if that object has a GetName method by doing this:

MethodInfo getName = x.GetType().GetMethod("GetName"); 

Suppose getName is not null. Then couldn't I furthermore check if getName.ReturnType == typeof(string) and getName.GetParameters().Length == 0, and at this point, wouldn't I be quite certain that the method represented by my getName object could definitely be cast to a Func<string>, somehow?

I realize there's a MethodInfo.Invoke, and I also realize I could always create a Func<string> like:

Func<string> getNameFunc = () => getName.Invoke(x, null); 

I guess what I'm asking is if there's any way to go from a MethodInfo object to the actual method it represents, incurring the performance cost of reflection in the process, but after that point being able to call the method directly (via, e.g., a Func<string> or something similar) without a performance penalty.

What I'm envisioning might look something like this:

// obviously this would throw an exception if GetActualInstanceMethod returned // something that couldn't be cast to a Func<string> Func<string> getNameFunc = (Func<string>)getName.GetActualInstanceMethod(x); 

(I realize that doesn't exist; I'm wondering if there's anything like it.)

Answer 1

This kind of replaces my previous answer because this, although it's a slightly longer route - gives you a quick method call and, unlike some of the other answers, allows you to pass through different instances (in case you're going to encounter multiple instances of the same type). IF you don't want that, check my update at the bottom (or look at Ben M's answer).

Here's a test method that does what you want:

public class TestType {   public string GetName() { return "hello world!"; } }  [TestMethod] public void TestMethod2() {   object o = new TestType();    var input = Expression.Parameter(typeof(object), "input");   var method = o.GetType().GetMethod("GetName",      System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);   //you should check for null *and* make sure the return type is string here.   Assert.IsFalse(method == null && !method.ReturnType.Equals(typeof(string)));    //now build a dynamic bit of code that does this:   //(object o) => ((TestType)o).GetName();   Func<object, string> result = Expression.Lambda<Func<object, string>>(     Expression.Call(Expression.Convert(input, o.GetType()), method), input).Compile();    string str = result(o);   Assert.AreEqual("hello world!", str); } 

Once you build the delegate once - you can cache it in a Dictionary:

Dictionary<Type, Func<object, string>> _methods; 

All you do then is add it to the dictionary, using the incoming object's Type (from GetType()) as the key. In the future, you first check to see if you have a ready-baked delegate in the dictionary (and invoke it if so), otherwise you build it first, add it in, and then invoke it.

Incidentally, this is a very highly simplified version of the kind of thing that the DLR does for it's dynamic dispatch mechanism (in C# terms, that's when you use the 'dynamic' keyword).

And finally

If, as a few people have mentioned, you simply want to bake a Func bound directly to the object you receive then you do this:

[TestMethod] public void TestMethod3() {   object o = new TestType();    var method = o.GetType().GetMethod("GetName",      System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);    Assert.IsFalse(method == null && !method.ReturnType.Equals(typeof(string)));    //this time, we bake Expression.Constant(o) in.   Func<string> result = Expression.Lambda<Func<string>>(    Expression.Call(Expression.Constant(o), method)).Compile();    string str = result(); //no parameter this time.   Assert.AreEqual("hello world!", str); } 

Note, though, that once the expression tree gets thrown away, you need to make sure that the o stays in scope, otherwise you could get some nasty results. The easiest way would be to hold on to a local reference (in a class instance, perhaps) for the lifetime of your delegate. (Removed as a result of Ben M's comments)

Answer 2

Yes, that's possible:

Func<string> func = (Func<string>)                      Delegate.CreateDelegate(typeof(Func<string>), getName);