Puoi usare la riflessione per trovare il nome del metodo attualmente in esecuzione?

Come dice il titolo: Può la riflessione darti il ​​nome del metodo attualmente in esecuzione.

Sono propenso a non indovinare, a causa del problema di Heisenberg. Come si chiama un metodo che ti dirà il metodo corrente senza cambiare quello che è il metodo corrente? Ma spero che qualcuno possa provare che mi sbaglio.

Aggiornare:

• Parte 2: Questo potrebbe essere usato anche per cercare nel codice una proprietà?
• Parte 3: come sarebbe la performance?

Risultato finale
Ho imparato su MethodBase.GetCurrentMethod (). Ho anche imparato che non solo posso creare una traccia dello stack, ma posso creare solo il frame esatto di cui ho bisogno se lo desidero.

Per usarlo all'interno di una proprietà, basta prendere un .Substring (4) per rimuovere 'set_' o 'get_'.

A partire da .NET 4.5 puoi anche usare [CallerMemberName]

Esempio: un setter proprietà (per rispondere alla parte 2):

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

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

Il compilatore fornirà letterali di stringa corrispondenti nei siti di chiamata, quindi non vi è praticamente alcun sovraccarico di prestazioni.

Per i non asyncmetodi si può usare

System.Reflection.MethodBase.GetCurrentMethod().Name;

https://docs.microsoft.com/en-us/dotnet/api/system.reflection.methodbase.getcurrentmethod

Ricorda che per i asyncmetodi restituirà "MoveNext".

Lo snippet fornito da Lex era un po 'lungo, quindi sto sottolineando la parte importante poiché nessun altro ha usato la stessa identica tecnica:

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

Ciò dovrebbe restituire risultati identici a MethodBase.GetCurrentMethod (). Tecnica del nome , ma vale comunque la pena sottolineare che potrei implementarlo una volta nel suo metodo usando l'indice 1 per il metodo precedente e chiamarlo da un numero di proprietà diverse. Inoltre, restituisce solo un fotogramma anziché l'intera traccia dello stack:

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

È anche un one-liner;)

Prova questo all'interno del metodo Main in un programma console vuoto:

MethodBase method = MethodBase.GetCurrentMethod();
Console.WriteLine(method.Name);

Uscita console:
Main

Sì, sicuramente.

Se vuoi manipolare un oggetto, in realtà utilizzo una funzione come questa:

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;
}

Questa linea:

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

Cammina nel frame dello stack per trovare il metodo di chiamata, quindi utilizziamo la riflessione per ottenere i valori delle informazioni sui parametri passati ad esso per una funzione di segnalazione errori generica. Per ottenere il metodo corrente è sufficiente utilizzare l'attuale stack frame (1).

Come altri hanno già detto per l'attuale nome dei metodi, puoi anche usare:

MethodBase.GetCurrentMethod()

Preferisco camminare nello stack perché, se guardi internamente a quel metodo, crea semplicemente StackCrawlMark comunque. Rivolgermi direttamente allo Stack mi sembra più chiaro

Post 4.5 ora puoi usare [CallerMemberNameAttribute] come parte dei parametri del metodo per ottenere una stringa del nome del metodo - questo può aiutare in alcuni scenari (ma in realtà nell'esempio sopra)

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

Questa sembrava essere principalmente una soluzione per il supporto di INotifyPropertyChanged in cui in precedenza avevi le stringhe disseminate per tutto il codice dell'evento.

Confronto tra i modi per ottenere il nome del metodo - usando un costrutto di temporizzazione arbitrario in LinqPad:

CODICE

void Main()
{
    // from http://blogs.msdn.com/b/webdevelopertips/archive/2009/06/23/tip-83-did-you-know-you-can-get-the-name-of-the-calling-method-from-the-stack-using-reflection.aspx
    // and /programming/2652460/c-sharp-how-to-get-the-name-of-the-current-method-from-code

    var fn = new methods();

    fn.reflection().Dump("reflection");
    fn.stacktrace().Dump("stacktrace");
    fn.inlineconstant().Dump("inlineconstant");
    fn.constant().Dump("constant");
    fn.expr().Dump("expr");
    fn.exprmember().Dump("exprmember");
    fn.callermember().Dump("callermember");

    new Perf {
        { "reflection", n => fn.reflection() },
        { "stacktrace", n => fn.stacktrace() },
        { "inlineconstant", n => fn.inlineconstant() },
        { "constant", n => fn.constant() },
        { "expr", n => fn.expr() },
        { "exprmember", n => fn.exprmember() },
        { "callermember", n => fn.callermember() },
    }.Vs("Method name retrieval");
}

// Define other methods and classes here
class methods {
    public string reflection() {
        return System.Reflection.MethodBase.GetCurrentMethod().Name;
    }
    public string stacktrace() {
        return new StackTrace().GetFrame(0).GetMethod().Name;
    }
    public string inlineconstant() {
        return "inlineconstant";
    }
    const string CONSTANT_NAME = "constant";
    public string constant() {
        return CONSTANT_NAME;
    }
    public string expr() {
        Expression<Func<methods, string>> ex = e => e.expr();
        return ex.ToString();
    }
    public string exprmember() {
        return expressionName<methods,string>(e => e.exprmember);
    }
    protected string expressionName<T,P>(Expression<Func<T,Func<P>>> action) {
        // https://stackoverflow.com/a/9015598/1037948
        return ((((action.Body as UnaryExpression).Operand as MethodCallExpression).Object as ConstantExpression).Value as MethodInfo).Name;
    }
    public string callermember([CallerMemberName]string name = null) {
        return name;
    }
}

RISULTATI

riflesso riflesso

stacktrace stacktrace

inlineconstant inlineconstant

costante costante

expr e => e.expr ()

exprmember exprmember

callermember Main

Method name retrieval: (reflection) vs (stacktrace) vs (inlineconstant) vs (constant) vs (expr) vs (exprmember) vs (callermember) 

 154673 ticks elapsed ( 15.4673 ms) - reflection
2588601 ticks elapsed (258.8601 ms) - stacktrace
   1985 ticks elapsed (  0.1985 ms) - inlineconstant
   1385 ticks elapsed (  0.1385 ms) - constant
1366706 ticks elapsed (136.6706 ms) - expr
 775160 ticks elapsed ( 77.516  ms) - exprmember
   2073 ticks elapsed (  0.2073 ms) - callermember


>> winner: constant

Si noti che i metodi expre callermembernon sono del tutto "giusti". E lì vedi una ripetizione di un commento correlato che la riflessione è ~ 15 volte più veloce di stacktrace.

EDIT: MethodBase è probabilmente un modo migliore per ottenere solo il metodo in cui ti trovi (al contrario dell'intero stack chiamante). Sarei comunque preoccupato per l'allineamento.

È possibile utilizzare StackTrace con il metodo:

StackTrace st = new StackTrace(true);

E lo sguardo alle cornici:

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

Tuttavia, tieni presente che se il metodo è inline, non sarai all'interno del metodo che ritieni di essere. È possibile utilizzare un attributo per impedire l'allineamento:

[MethodImpl(MethodImplOptions.NoInlining)]

Il modo semplice di trattare è:

System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + System.Reflection.MethodBase.GetCurrentMethod().Name;

Se System.Reflection è incluso nel blocco using:

MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + MethodBase.GetCurrentMethod().Name;

Che ne dici di questo:

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

Penso che dovresti essere in grado di ottenerlo dalla creazione di StackTrace . Oppure, come menzionano @ edg e @ Lars Mæhlum , MethodBase. GetCurrentMethod ()

Prova questo...

    /// <summary>
    /// Return the full name of method
    /// </summary>
    /// <param name="obj">Class that calls this method (use Report(this))</param>
    /// <returns></returns>
    public string Report(object obj)
    {
        var reflectedType = new StackTrace().GetFrame(1).GetMethod().ReflectedType;
        if (reflectedType == null) return null;

        var i = reflectedType.FullName;
        var ii = new StackTrace().GetFrame(1).GetMethod().Name;

        return string.Concat(i, ".", ii);
    }

L'ho appena fatto con una semplice classe statica:

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

quindi nel tuo codice:

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

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

new StackTrace().ToString().Split("\r\n",StringSplitOptions.RemoveEmptyEntries)[0].Replace("at ","").Trim()