Vous pouvez obtenir un Func<T> (ou similaire) à partir d'un MethodInfo objet?

Ce genre de remplace ma précédente réponse, car ce, bien qu'il soit un peu plus de la route vous donne un rapide appel de méthode et, contrairement à certains des autres réponses, vous permet de passer à travers différentes instances (dans le cas où vous allez à la rencontre de plusieurs instances d'un même type). SI vous ne le souhaitez pas, cochez ma mise à jour en bas (ou regarder Ben M de la réponse).

Voici une méthode de test qui fait ce que vous voulez:

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);
}

Une fois que vous générez le délégué une fois - vous pouvez mettre en cache dans un Dictionnaire:

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

Tout ce que vous faire est alors de l'ajouter au dictionnaire, à l'aide de l'entrant de Type de l'objet (à partir de GetType()) comme clé. Dans l'avenir, vous devez d'abord vérifier si vous avez un prêt-cuit délégué dans le dictionnaire (et à l'appeler si si), sinon vous construire d'abord, l'ajouter dans les, puis de l'appeler.

D'ailleurs, c'est un très très version simplifiée de la sorte de chose que la RDL ne pour la répartition dynamique du mécanisme (en C#, c'est lorsque vous utilisez la "dynamique" mot-clé).

Et enfin

Si, comme quelques personnes l'ont mentionné, tout simplement, vous voulez faire cuire un Func directement lié à l'objet que vous recevez ensuite vous faites cela:

[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);
}

Notez, cependant, qu'une fois l'expression de l'arbre se jette pas, vous devez vous assurer que le o reste dans la portée, sinon, vous pourriez obtenir certains méchant résultats. Le plus simple serait de tenir un local de référence (dans une instance de classe, peut-être) pour la durée de vie de votre délégué. (Supprimé à la suite de Ben M commentaires)

Voici ma réponse, par la construction d'une arborescence d'expression. Contrairement à d'autres réponses, le résultat (getNameFunc) est une fonction qui est lié à l'instance d'origine, sans avoir à passer comme paramètre.

class Program
{
    static void Main(string[] args)
    {
        var p = new Program();
        var getNameFunc = GetStringReturningFunc(p, "GetName");
        var name = getNameFunc();
        Debug.Assert(name == p.GetName());
    }

    public string GetName()
    {
        return "Bob";
    }

    static Func<string> GetStringReturningFunc(object x, string methodName)
    {
        var methodInfo = x.GetType().GetMethod(methodName);

        if (methodInfo == null ||
            methodInfo.ReturnType != typeof(string) ||
            methodInfo.GetParameters().Length != 0)
        {
            throw new ArgumentException();
        }

        var xRef = Expression.Constant(x);
        var callRef = Expression.Call(xRef, methodInfo);
        var lambda = (Expression<Func<string>>)Expression.Lambda(callRef);

        return lambda.Compile();
    }
}

Vous pourriez construire une Arborescence d'Expression représentant un lambda de l'appel à cette méthode, puis Compile() de sorte que plus d'appels sera aussi rapide que la norme compilé des appels.

Sinon, j'ai écrit cette méthode un bon moment, il ya appuie sur un article de MSDN, qui génère un wrapper utilisant IL de faire appel à d' MethodInfo manière plus rapide qu'avec MethodInfo.DynamicInvoke car une fois le code généré, il n'y a presque pas de frais généraux au cours d'un appel normal.