Convert C# method name to text

Question

I am using a generic handler in Visual Studio 2013.

What I am trying to do is to create a URL that incorporates the name of a method, but I want the name of the method to be real code so that it will not be hard-coded and follow along if the function name was changed.

If I were doing this in C or C++, I would have just said:

#define GENERATE_REFERENCE(text) #text

I don't really care it is formed as a method call as I have prototyped here

"Pseudo-code" in C# of what I am trying to do:

public class MyClass {
    public void SayHello (String name)
    {
    ...
    }

    public void GenerateLink()
    {
         url = "... "+GenerateReference(this.SayHello);
         // url would be "... SayHello";

    }
    public String GenerateReference( DataType method )
    {
         // Is there some way to do this?
         return method.MethodName.ToString();
    }
}

My question is different than the suggested duplicate question get methodinfo from a method reference C# because my question comes from a place of great ignorance of C# mechanisms (neophyte). The suspected duplicate question implies a much higher level of understanding well beyond what I demonstrated in my question - I didn't know enough to ask that question. I would have never have found this answer from my searching.

Answer 1

C# 6

nameof(MyClass.SayHello)

Before C# 6

public static String GenerateReference<T>(Expression<Action<T>> expression)
{
    var member = expression.Body as MethodCallExpression;

    if (member != null)
        return member.Method.Name;

    throw new ArgumentException("Expression is not a method", "expression");
}

GenerateReference<MyClass>(c => c.SayHello(null));

Credit goes to https://stackoverflow.com/a/9382501/471321

Answer 2

c# 6 introduces a new operator called nameof which eliminates these hardcoded string with method names.

You can use it as follows: nameof(Class.Method)

Answer 3

C#6.0 Does include the nameof feature. However, knowing you're in VS2013 and C#6.0 is not enabled by default; I suggest using System.Reflection.

I would use something as such.

System.Reflection.MethodBase.GetCurrentMethod().Name

and pass the name of the method as a parameter if needed.

Cheers!

Answer 4

This is probably the simplest way for your use case;

Action<string> del = this.SayHello;
string ret = del.Method.Name;

Answer 5

You can use the CallerMemberNameAttribute on the parameter in order to have the compiler insert the name for you in earlier versions of C#.

Here is a sample that relies on overloading to get the right answer. Note that if your "real" methods all have unique parameters of their own, you don't need the dummy overload and can avoid the QueryMethodNameHelper argument altogether

// This class is used both as a dummy parameter for overload resolution
// and to hold the GetMyName method. You can call it whatever you want
class QueryMethodNameHelper
{
  private QueryMethodNameHelper() { }

  public static readonly QueryMethodNameHelper Instance = 
    new QueryMethodNameHelper();

  public static string GetMyName([CallerMemberName] string 
    name = "[unknown]")
  {
    return name;
  }
}

class Program
{
  // The real method
  static void SayHello()
  {
    Console.WriteLine("Hello!");
  }

  // The dummy method; the parameter is never used, but it ensures
  // we can have an overload that returns the string name
  static string SayHello(QueryMethodNameHelper dummy)
  {
    return QueryMethodNameHelper.GetMyName();
  }

  // Second real method that has an argument
  static void DoStuff(int value)
  {
    Console.WriteLine("Doing stuff... " + value);
  }

  // Dummy method can use default parameter because
  // there is no ambiguity
  static string DoStuff(QueryMethodNameHelper dummy = null)
  {
    return QueryMethodNameHelper.GetMyName();
  }

  static void Main(string[] args)
  {
    string s = SayHello(QueryMethodNameHelper.Instance);
    Console.WriteLine(s);
    SayHello();

    string s2 = DoStuff();
    Console.WriteLine(s2);
    DoStuff(42);
  }
}

This sample has the benefit of injecting the string at compile-time (there is no runtime overhead to lookup metadata) but it does require you to keep the method names in sync (eg, if you rename the "real" SayHello you also need to rename the helper SayHello). Luckily the Refactor dialog will do that for you if you click the "Rename overloads" checkbox, but it's not on by default.

Answer 6

Use System.Reflection (pre C#6.0):

typeof(MyClass).GetMethod("SayHello").Name

or nameof for C#6.0 and later:

nameof(SayHello)