Pouvez-vous utiliser la réflexion pour trouver le nom de la méthode d'exécution actuelle?

Comme de .NET 4.5, vous pouvez également utiliser [CallerMemberName]

Exemple: une propriété setter (pour répondre à la partie 2):

    protected void SetProperty<T>(T value, [CallerMemberName] string property = null)
    {
        this.propertyValues[property] = value;
        OnPropertyChanged(property);
    }

    public string SomeProperty
    {
        set { SetProperty(value); }
    }

Le compilateur offre répondant à des littéraux de chaîne à callsites, donc il n'y a fondamentalement pas de surcharge de performance.

L'extrait fourni par la Lex était un peu long, donc je suis en soulignant le rôle important puisque personne d'autre a utilisé exactement la même technique:

string MethodName = new StackFrame(0).GetMethod().Name;

Cela devrait renvoyer des résultats identiques à la MethodBase.GetCurrentMethod().Nom technique, mais il vaut la peine de souligner, car j'ai pu mettre en œuvre cette fois dans son propre méthode à l'aide de l'index 1 pour la précédente méthode et l'appeler à partir d'un certain nombre de propriétés différentes. Aussi, il ne renvoie une image plutôt que de l'ensemble de la trace de la pile:

private string GetPropertyName()
{  //.SubString(4) strips the property prefix (get|set) from the name
    return new StackFrame(1).GetMethod().Name.Substring(4);
}

C'est un one-liner, trop 😉

Oui certainement.

Si vous voulez un objet à manipuler j'utilise une fonction comme ceci:

public static T CreateWrapper<T>(Exception innerException, params object[] parameterValues) where T : Exception, new()
{
    if (parameterValues == null)
    {
        parameterValues = new object[0];
    }

    Exception exception   = null;
    StringBuilder builder = new StringBuilder();
    MethodBase method     = new StackFrame(2).GetMethod();
    ParameterInfo[] parameters = method.GetParameters();
    builder.AppendFormat(CultureInfo.InvariantCulture, ExceptionFormat, new object[] { method.DeclaringType.Name, method.Name });
    if ((parameters.Length > 0) || (parameterValues.Length > 0))
    {
        builder.Append(GetParameterList(parameters, parameterValues));
    }

    exception = (Exception)Activator.CreateInstance(typeof(T), new object[] { builder.ToString(), innerException });
    return (T)exception;
}

Cette ligne:

MethodBase method     = new StackFrame(2).GetMethod();

Promenades en place la trame de pile à trouver la méthode d'appel puis nous avons utiliser la réflexion pour obtenir des informations sur le paramètre des valeurs transmises pour le générique de la fonction de rapport d'erreurs. Pour obtenir la méthode actuelle tout simplement utiliser de pile actuel cadre (1) à la place.

Comme d'autres l'ont dit pour les méthodes actuelles de nom, vous pouvez également utiliser:

MethodBase.GetCurrentMethod()

Je préfère la marche de la pile car si regarder intérieurement à cette méthode, il crée simplement un StackCrawlMark de toute façon. L'adressage de la Pile directement semble plus clair pour moi

Post 4.5 vous pouvez maintenant utiliser la [CallerMemberNameAttribute] dans le cadre de la méthode des paramètres pour obtenir une chaîne de caractères du nom de la méthode, qui peut aider dans certains scénarios (mais vraiment dans l'exemple ci-dessus)

public void Foo ([CallerMemberName] string methodName = null)

Il semble que ce soit surtout une solution pour INotifyPropertyChanged soutien là où auparavant vous aviez des chaînes éparpillées à travers votre code d'événement.

EDIT: MethodBase est probablement une meilleure solution pour obtenir juste la méthode que vous êtes (par opposition à l'ensemble de la pile d'appel). Je serais toujours préoccupé par l'in-lining cependant.

Vous pouvez utiliser une StackTrace à l'intérieur de la méthode:

StackTrace st = new StackTrace(true);

Et le regard sur les images:

//The first frame will be the method you want (However, see caution below)
st.GetFrames();

Toutefois, sachez que si la méthode est inline, vous ne serez pas à l'intérieur de la méthode que vous pensez de vous. Vous pouvez utiliser un attribut pour empêcher l'in-lining:

[MethodImpl(MethodImplOptions.NoInlining)]

Comment à ce sujet ceci:

StackFrame frame = new StackFrame(1);
frame.GetMethod().Name; //Gets the current method name
MethodBase method = frame.GetMethod();
method.DeclaringType.Name //Gets the current class name

Si vous avez besoin simplement le nom de la chaîne de la méthode, vous pouvez utiliser des Expressions. Voir http://joelabrahamsson.com/entry/getting-property-and-method-names-using-static-reflection-in-c-sharp

Je viens de le faire avec une simple classe statique:

using System.Runtime.CompilerServices;
.
.
.
public static class MyMethodName
{
public static string Show([CallerMemberName] string name = "")
{
return name;
}
}

puis dans votre code:

private void button1_Click(object sender, EventArgs e)
{
textBox1.Text = MyMethodName.Show();
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Text = MyMethodName.Show();
}