Pass method as parameter

Question

I am using a library in C# where a method requires that I pass the string name of a target method as a parameter.

I want to avoid using hardcoded strings for obvious reasons, so I will write an intermediate util method that takes a method, gets the name (presumably via reflection) and feeds it into the library method.

I expect the intermediate method to look something like this:

public void CallOtherMethod(???? inputMethod)
{
    string methodName = inputMethod.Name; // This gives me the method without the namespace, right?
    this.CallFinalMethod(methodName);
}

To be called like this:

this.CallOtherMethod(this.SomeOtherMethod);

However, I'm having some trouble figuring out the type required to do this.

How can I correctly define my method?

As a side note, I would happily write this as an extension method to the library, but this doesn't quite work with the way the library behaves.

Answer 1

Try to use Action or Func like this:

public void CallOtherMethod(Action method)
{
    string methodName = method.Method.Name;
    method.Invoke();
}

 public void AnotherMethod(string foo, string bar)
{
    // Do Something
}

Call:

CallOtherMethod( () => AnotherMethod("foo", "bar") );

Answer 2

If your library constrains methods to have a certain signature (e.g., 0 parameters, return void), then you can use a delegate with the appropriate signature.

For example, an Action represents a method with 0 parameters that returns void.

public void CallOtherMethodMethodGroup(Action action)
{
    MethodInfo method = action.Method;

    //check that 'action' is not a compiler generated lambda
    if (!method.IsDefined(typeof (CompilerGeneratedAttribute)))
    {
        Console.WriteLine(method.Name);
    }
    else
        throw new InvalidOperationException("Use 'CallOtherMethodExpr' instead.");
}

And call it using a method group:

CallOtherMethodMethodGroup(AnotherMethod);

If your library accepts a method with any kind of signature, then use you'll have to pass in a lambda instead of a method group:

CallOtherMethodExpr(() => AnotherMethod("dummy", "arg"));

But, when using a lambda, you'll have to change the method to accept an Expression<Action> instead of Action. An expression can be interpreted, a delegate can't.

public void CallOtherMethodExpr(Expression<Action> expr)
{
    string methodName;

    if (expr.Body.NodeType == ExpressionType.Call)
    {
        var call = expr.Body as MethodCallExpression;
        methodName = call.Method.Name;
    }
    else
        throw new InvalidOperationException("Expression must contain a method call");

    Console.WriteLine(methodName);
}

Answer 3

As I understand this, the question isn't how to call a method via a delegate, but how to get the name of a method without resorting to magic strings.

Using reflection doesn't make the magic strings go away. You can get all methods of a type with a specific signature, but you still need to know the name of the method you are targeting. A simple rename refactoring will still break your code.

A typical solution in such cases is to pass an Expression pointing to the member you want. This is used extensively in MVVM frameworks to pass the name of any modified parameters

The following method will check if the supplied expression is an actual method call and extract the method's name:

    public static bool TryGetName(Expression<Action> expr, out string memberName)
    {
        memberName = null;
        var body = expr.Body as MethodCallExpression;
        if (body == null)
            return false;
        memberName = body.Method.Name;
        return true;
    }

The method can be called like this:

bool success=TryGetName(()=>someObject.SomeMethod(), out name);

All Action and Func objects inherit from Action, which means that SomeMethod may actually be a function. If the method contains parameters, the call will need some dummy values:

bool success=TryGetName(()=>someObject.SomeMethod(null,"dummy",0), out name);

Answer 4

You need Delegate

public void OtherMethod(Action method)
{
   MessageBox.Show("I am raised first.");
   string methodname = method.Method.Name;
   method.Invoke();
}

public void SomeMethod()
{
    some code ...
}

if you use a named method for Calling the OtherMethod

OtherMethod(SomeMethod);

methodName is set to "SomeMethod",
but if you use anonymous methods for Calling it

OtherMethod(() => MessageBox.Show("The main thing ..."));

then you'll get a nasty compiler-generated name like <YourNamespaceName_Load>b__0