Obtener el nombre de un método utilizando una expresión

Question

Sé que hay algunas respuestas en el sitio al respecto y me disculpo si esto se duplica de alguna manera, pero todas las que encontré no hacen lo que intento. hacer.

Estoy tratando de especificar la información del método para que pueda obtener el nombre de una manera segura al no usar cadenas. Así que estoy tratando de extraerlo con una expresión.

decir que quiero obtener el nombre de un método en esta interfaz:

public interface IMyInteface 
{ 
    void DoSomething(string param1, string param2); 
} 

Actualmente puedo obtener el nombre utilizando este método:

MemberInfo GetMethodInfo<T>(Expression<Action<T>> expression) 
{ 
     return ((MethodCallExpression)expression.Body).Method; 
} 

me puede llamar al método de ayuda de la siguiente :

var methodInfo = GetMethodInfo<IMyInteface>(x => x.DoSomething(null, null)); 
Console.WriteLine(methodInfo.Name); 

Pero estoy buscando la versión que me permita obtener el nombre del método sin especificar los parámetros (null, null)

así:

var methodInfo = GetMethodInfo<IMyInteface>(x => x.DoSomething); 

Pero todos los intentos fallan para compilar

¿Hay una manera de hacer esto?

Answer 1

x => x.DoSomething 

Con el fin de hacer de este compilables sólo veo dos formas:

1. Ir manera no genérico y especificar que es parámetro como Action<string, string>
2. especificar Action<string, string> como su target tipo de delegado en solitario: GetMethodInfo<IMyInteface>(x => new Action<string,string>(x.DoSomething))

si estás bien para ir con segundo, lo que le permite omitir los argumentos a continuación, se puede escribir el método de GetMethodInfo de la siguiente manera:

MemberInfo GetMethodInfo<T>(Expression<Func<T, Delegate>> expression) 
    { 
     var unaryExpression = (UnaryExpression) expression.Body; 
     var methodCallExpression = (MethodCallExpression) unaryExpression.Operand; 
     var methodInfoExpression = (ConstantExpression) methodCallExpression.Arguments.Last(); 
     var methodInfo = (MemberInfo) methodInfoExpression.Value; 
     return methodInfo; 
    } 

Funciona para su interfaz, pero probablemente será necesaria una generalización para que funcione con cualquier método, eso depende de usted.

Answer 2

Si su aplicación permitiría una dependencia de Moq (o una biblioteca similar), se podría hacer algo como esto:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var methodName = GetMethodName<IMyInteface>(x => new Action<string,string>(x.DoSomething)); 
     Console.WriteLine(methodName); 
    } 

    static string GetMethodName<T>(Func<T, Delegate> func) where T : class 
    { 
     // http://code.google.com/p/moq/ 
     var moq = new Mock<T>(); 
     var del = func.Invoke(moq.Object); 
     return del.Method.Name; 
    } 
} 

public interface IMyInteface 
{ 
    void DoSomething(string param1, string param2); 
} 

Answer 3

El problema con esto es que x.DoSomething representa un grupo de métodos. Y tiene que especificar de forma explícita a qué tipo de delegado desea convertir ese grupo de métodos, para que se pueda seleccionar el miembro correcto del grupo. Y no importa si ese grupo contiene solo un miembro.

El compilador podría inferir que se refiere a eso, pero no hace eso. (Creo que es así para que su código no se rompa si agrega otra sobrecarga de ese método.)

La respuesta de Snowbear contiene buenos consejos sobre posibles soluciones.

Answer 4

Esta es una nueva respuesta a una pregunta anterior, pero responde a la queja "verbosa" de la respuesta aceptada. Se requiere más código, pero el resultado es una sintaxis como:

MemberInfo info = GetActionInfo<IMyInterface, string, string>(x => x.DoSomething); 

o, para los métodos con un valor de retorno

MemberInfo info = GetFuncInfo<IMyInterface, object, string, string>(x => x.DoSomethingWithReturn); 

donde

object DoSomethingWithReturn(string param1, string param2); 

Al igual que el marco proporciona una acción < > y Func <> delega hasta 16 parámetros, debe tener los métodos GetActionInfo y GetFuncInfo que aceptan hasta 16 parámetros (o más, aunque creo que la refactorización es sabio si tienes métodos con 16 parámetros). Mucho más código, pero una mejora en la sintaxis.

Answer 5

El siguiente es compatible con .NET 4.5:

public static string MethodName(LambdaExpression expression) 
{ 
    var unaryExpression = (UnaryExpression)expression.Body; 
    var methodCallExpression = (MethodCallExpression)unaryExpression.Operand; 
    var methodCallObject = (ConstantExpression)methodCallExpression.Object; 
    var methodInfo = (MethodInfo)methodCallObject.Value; 

    return methodInfo.Name; 
} 

Usted puede utilizarlo con expresiones como x => x.DoSomething, sin embargo, requeriría alguna envoltura en métodos genéricos para diferentes tipos de métodos.

Aquí es una versión compatible con versiones anteriores:

private static bool IsNET45 = Type.GetType("System.Reflection.ReflectionContext", false) != null; 

public static string MethodName(LambdaExpression expression) 
{ 
    var unaryExpression = (UnaryExpression)expression.Body; 
    var methodCallExpression = (MethodCallExpression)unaryExpression.Operand; 
    if (IsNET45) 
    { 
     var methodCallObject = (ConstantExpression)methodCallExpression.Object; 
     var methodInfo = (MethodInfo)methodCallObject.Value; 
     return methodInfo.Name; 
    } 
    else 
    { 
     var methodInfoExpression = (ConstantExpression)methodCallExpression.Arguments.Last(); 
     var methodInfo = (MemberInfo)methodInfoExpression.Value; 
     return methodInfo.Name; 
    } 
} 

Comprobar this sample code on Ideone. Tenga en cuenta que Ideone no tiene .NET 4.5.