Obtenir le nom d'une méthode non statique dans une méthode statique

Question

J'essaie de faire quelque chose d'assez simple mais je ne suis pas sûr qu'il y ait un moyen de contourner la création d'une instance fictive de ma classe.

J'essaie d'obtenir simplement le nom de la méthode d'une méthode non statique en utilisant un code simple :

static string GetMethodName(Func<string, int> function  )
        {
            return function.Method.Name;
        }

Cependant, j'essaie d'appeler cette fonction à partir de MyStaticMethod comme suit et, bien entendu, le système se plaint :

private static void MyStaticMethod()
{
   var a = GetMethodName(MyNonStaticMethod);
}

private int MyNonStaticMethod(string param1)
{
  return 0;
}

Y a-t-il un moyen d'y parvenir sans créer une instance fictive de la classe qui la contient ? Mon cas est évidemment plus complexe et je ne peux pas simplement rendre statique ma méthode non statique (elle nécessite une instance et a des liens de dépendance). Je me demande juste si c'est possible car tout ce dont j'ai besoin est le nom (donc je n'ai pas vraiment besoin d'une instance). J'essaie de m'éloigner des chaînes magiques et je veux des erreurs de compilation lorsque les choses changent.

edit : J'ai créé une classe d'aide statique

J'ai une méthode générique :

    public static string GetMemberName<T>(
                Expression<Func<T, object>> expression)
            {
                if (expression == null)
                {
                    throw new ArgumentNullException("expression");
                }

                return _GetMemberName(expression.Body);
            }

private static string _GetMemberName(
            Expression expression)
        {   
            if (expression is MemberExpression)
            {
                var memberExpression =
                    (MemberExpression)expression;
                return memberExpression.Member.Name;
            }

            if (expression is MethodCallExpression)
            {
                var methodCallExpression = (MethodCallExpression)expression;
                return methodCallExpression.Method.Name;
            }

            if (expression is UnaryExpression)
            {
                var unaryExpression = (UnaryExpression)expression;
                return GetMemberName(unaryExpression);
            }

            throw new ArgumentException("Unrecognized expression");
        }

Answer 1

Bien sûr, vous pouvez le faire. Utilisez Expression<Func<YourInstanceClass, TReturn>> comme ça :

static string GetMethodName<TReturn>(Expression<Func<YourInstanceClass, TReturn>> function)
{
    var call = function.Body as MethodCallExpression;
    return call != null ? call.Method.Name : "not a single call expression";
}

maintenant vous pouvez

var name = GetMethodName(a => a.MyNonStaticMethod("1"));

Console.WriteLine (name); //prints MyNonStaticMethod

donde

public class YourInstanceClass
{
    public int MyNonStaticMethod(string param1)
    {
        return 0;
    }
}

J'ai fait MyNonStaticMethod public, afin que je puisse l'appeler à l'extérieur, mais vous pouvez le laisser privé et l'appeler dans une méthode statique à l'intérieur d'une classe.