Можно ли получить Func <T> (или подобный) от объекта MethodInfo?

Вот мой ответ - построение дерева выражений. В отличие от других ответов, результат ( getNameFunc ) представляет собой функцию, которая привязана к исходному экземпляру - без необходимости передавать ее в качестве параметра.

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

Один из самых важных моих подходов - использовать динамический. Тогда вы могли бы сделать что-то вроде этого:

if( /* This method can be a Func<string> */)
{
    dynamic methodCall = myObject;
    string response = methodCall.GetName();
}

Да, это возможно:

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

Вы можете построить дерево выражений, представляющее лямбду, вызывающую этот метод, а затем Compile() его так, что дальнейшие вызовы будут такими же быстрыми, как и стандартные скомпилированные вызовы.

В качестве альтернативы я написал этот метод некоторое время назад на основе замечательной статьи в MSDN, который генерирует обертку с использованием IL для вызова любого MethodInfo намного быстрее, чем с помощью MethodInfo.DynamicInvoke, поскольку после генерации кода почти нет накладных расходов по сравнению с обычным вызовом.

Проще всего это сделать через Delegate. CreateDelegate:

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

Обратите внимание, что это связывает getNameFunc с x, поэтому для каждого x вам придется создавать новый экземпляр делегата. Этот вариант гораздо менее сложен, чем примеры на основе Expression. Однако в примерах на основе Expression можно один раз создать Func getNameFuncForAny, который можно повторно использовать для каждого экземпляра MyClass.

Чтобы создать такой getNameFuncForAny, вам понадобится метод типа

public Func<MyClass, string> GetInstanceMethod(MethodInfo method)
{
    ParameterExpression x = Expression.Parameter(typeof(MyClass), "it");
    return Expression.Lambda<Func<MyClass, string>>(
        Expression.Call(x, method), x).Compile();
}

который можно использовать следующим образом:

Func<MyClass, string> getNameFuncForAny = GetInstanceMethod(getName);

MyClass x1 = new MyClass();
MyClass x2 = new MyClass();

string result1 = getNameFuncForAny(x1);
string result2 = getNameFuncForAny(x2);

Если вы не хотите быть привязанным к Func, вы можете определить

public TDelegate GetParameterlessInstanceMethod<TDelegate>(MethodInfo method)
{
    ParameterExpression x = Expression.Parameter(method.ReflectedType, "it");
    return Expression.Lambda<TDelegate>(
        Expression.Call(x, method), x).Compile();
}