Get name of function in c#

Question

In Unity when using coroutines or InvokeRepeating, you have to give a string with the name of the function you want to call. Though this is a pain if you change the name of that function, since you have to remember to change the coroutines that use it. Is there a cleaner way of doing this?

Currently it looks like this:

InvokeRepeating ("SendChangedValues", SEND_RATE, SEND_RATE);

though it would be nice to have something like

InvokeRepeating (SendChangedValues.Name(), SEND_RATE, SEND_RATE); //or
InvokeRepeating (functions.GetName(SendChangedValues), SEND_RATE, SEND_RATE);

Is this possible in c#? Or something else that makes sure I get an error/warning when I change the function's name without changing those strings.

Edit 1: The cleanest thing I could think of is making a const string with the function's name, and putting it just before the function itself. So it's harder to forget to change the string, since it's right there above it, and I also only have to change that one const string to change all the coroutines.

Thanks!

Answer 1

ahhh.. if it were next the C# version, you could have used the nameof operator.

for now, Does this help your cause?

private static string GetFunctionName(Action method)
{
 return method.Method.Name;
}

called using:

string methodName = GetFunctionName(SendChangedValues);

you might want to explore different delegate types.. Action, Func etc.

the only problem with above is that for every method signature, you might need to define the right signature/overloads to get name.

Answer 2

Coroutines do allow it IF you aren't passing in an extra parameter. The first example in the documentation shows an overload with the signature of Coroutine StartCoroutine(IEnumerator routine);:

using UnityEngine;
using System.Collections;

public class Example : MonoBehaviour {
    void Start() {
        print("Starting " + Time.time);
        StartCoroutine(WaitAndPrint(2.0F));
        print("Before WaitAndPrint Finishes " + Time.time);
    }
    IEnumerator WaitAndPrint(float waitTime) {
        yield return new WaitForSeconds(waitTime);
        print("WaitAndPrint " + Time.time);
    }
}

InvokeRepeating, unfortunately, does not have this same overload. You should be able to accomplish it there using reflection though as mentioned in some of the other answers.

Answer 3

I use the following in my codebase, extrapolate for invokerepeating.

public delegate void Task();

public static class MonoBehaviourExtensions {
  public static void InvokeLater(
    this MonoBehaviour b,
    float time,
    Task task)
  {
    b.Invoke(task.Method.Name, time);
  }
}

Use it like this

public class MyBehaviour : MonoBehaviour {
  void Start(){
    this.InvokeLater(1f, DoSomething1SecondLater);
  }

  public void DoSomething1SecondLater(){
    Debug.Log("Welcome to the future");
  }
}

Answer 4

I understand your problem and I don't have a golden solution for this.

What might help is using lambda expressions as a way to figure it out like in this blog post.

It describes a way to figure out the method name by passing an Expression that will be evaluated as MethodCallExpression. From there you can extract the relevant information.

Answer 5

I remember doing something similar in another context. It went something like this:

You declare a method of your own, that uses the original method:

public static void MyInvokeRepeating<T>(Func<T> method)
{
    InvokeRepeating(method.Method.Name, SEND_RATE, SEND_RATE);
}

and then call your method like this

MyInvokeRepeating(someObject.SomeFunction);

Better yet, make an extension method.

Answer 6

You can do this via static reflection (in at least .NET 4, maybe 3.5 and below)

// This
InvokeRepeating(((MethodCallExpression)((Expression<Action<string>>)(x => x.ToString())).Body).Method.Name, SEND_RATE, SEND_RATE);

// Is the same as
InvokeRepeating("ToString", SEND_RATE, SEND_RATE);

You just need to know the signature of the function you're calling and replace the Action in the example above accordingly.

Answer 7

Make an enum out of the coroutines you have:

public enum MyCoroutines
{ 
Coroutine1,
Coroutine2
}

InvokeRepeating(MyCoroutines.Coroutine1.ToString(), x, y);

This way you have no danger of misspelling the function names plus you can find and replace them easily. It's also very good for playing sounds and animations.

Answer 8

No lambda expression needed when you're dealing with a method (not a property or field).

You can write an InvokeRepeating wrapper that takes a delegate. Call GetInvocationList on the delegate to get the MethodInfo, which has the name.

Answer 9

Here is my take on the matter, since I've recently stumbled upon this problem in context of UnityEvent listeners, which are also stored and can only be retrieved via the method's name. My approach makes more sense when dealing with event handler with different signatures, but it works for any Action and Invoke as well.

public void Start()
{
    Invoke(
        methodName : GetMethodName((System.Action)Explode), 
        time: 1f);

    Invoke(
        methodName : GetMethodName((System.Action<int>)HandleMyNumber), 
        time: 2f);
}

public static string GetMethodName(System.Delegate @delegate)
{
    return @delegate.Method.Name;
}

private void Explode()
{
    // Do something Action like...   
}

private void HandleMyNumber(int number)
{
    // Do something Action<int> like...
}

As others have mentioned before, the simplest way of retrieving the MethodInfo to get a method's name, is via a delegate type such as Action. I wouldn't want to specify overloads for every delegate type such as Action, Action, Action, because I don't use those parameters. Instead I can just cast whatever method I would pass as a parameter to it's correct type.