Uso de un método fuertemente tipado como argumento sin especificar parámetros

Question

¿Es posible pasar el nombre fuertemente tipado de un método como una expresión lambda sin proporcionar también los parámetros y/o paréntesis?

Por ejemplo, si tengo el siguiente método:

public class CalleeClass 
{ 
    public void MethodA(obj param1, obj param2) 
    { 
     ... 
    } 
} 

me gustaría llamar a este método en otros lugares a través de:

return new MyClass<CalleeClass>(c => c.MethodA); //Note: no()'s or arguments 

Dónde MiClase serían responsables de, digamos, MVC enrutamiento usando el nombre del método como el objetivo. El objetivo aquí es que queremos poder usar vistas fuertemente tipadas a través de métodos de control, y no quiero tener que proporcionar parámetros "tontos" que no se usen.

Actualmente, estoy usando un código similar al siguiente para usar los nombres de los métodos, pero este estilo todavía requiere pasar argumentos falsos y/o paréntesis.

public void MyClass<T>(Expression<Action<T>> action) 
{ 
    var methodName = (action.Body as MethodCallExpression).Method.Name; 
} 

EDIT: Lo siento por la confusión, pero inicialmente trató de simplificar el problema al incluir únicamente lo que pensé que había necesidad, y al hacerlo dejado fuera algo de información clave. El objetivo final aquí es que MyClass reciba un tipo genérico + expresión lambda, y la expresión lambda puede pasar en el nombre del método fuertemente tipado sin instanciar un objeto. -MB

Answer 1

En realidad puede pasar al método sin parámetros:

class PassActionTest 
{ 
    public void Test() 
    { 
     var c = new C(); 
     var myClass = new MyClass(c.MethodA); 
    } 
} 

class MyClass 
{ 
    public MyClass(Action<object,object> action) 
    { 
     string methodName = action.Method.Name; 
    } 
} 

class C 
{ 
    public void MethodA(object param1, object param2) 
    { 
    } 
} 

EDITAR: Según EDITAR de Matt Beckman, la clase que contiene MethodA no debe ser instanciada. Mi nueva solución es:

class PassActionTest 
{ 
    public void Test() 
    { 
     var myClass = new MyClass(c => c.MethodA); 
    } 
} 

class MyClass 
{ 
    public MyClass(Expression<Func<C, Action<object, object>>> expr) 
    { 
     UnaryExpression unaryExpr = (UnaryExpression)expr.Body; 
     MethodCallExpression methodCallExpr = (MethodCallExpression)unaryExpr.Operand; 
     ConstantExpression constantExpr = (ConstantExpression)methodCallExpr.Arguments[2]; 
     MethodInfo methodInfo = (MethodInfo)constantExpr.Value; 
     string methodName = methodInfo.Name; 
    } 

} 

class C 
{ 
    public void MethodA(object param1, object param2) 
    { 
    } 
} 

Es un poco complicado analizar la expresión, pero la he probado y funciona.

Answer 2

Se puede declarar un delegado a juego de la firma del método MethodA() y utilizar el delegado como parámetro al constructor de la clase MiClase

public delegate void MethodADelegate(object param1, object param2); 

public MyClass(MethodADelegate methodParam) 
{ 
    //use the methodParam parameter 
} 

Alternativamente, se puede utilizar la acción <> delegado presente en .Net como lo sugiere @Olivier

Answer 3

Si solo necesita el nombre del método, le recomiendo usar Delegate (http://msdn.microsoft.com/en-us/library/system.delegate.aspx) :

public MyClass(Delegate action) 
{ 
    var methodName = action.Method.Name; 
} 

Esto funciona, excepto que creo que tendrá que especificar el tipo de delegado al pasar en:

{ 
    ... 
    return new MyClass((Action<object,object>)c.MethodA); 
} 

Esto va a mantener todo inflexible-tal que refactorización va a funcionar, también.