Können Sie mithilfe von Reflection den Namen der aktuell ausgeführten Methode ermitteln?

Wie der Titel schon sagt: Kann Reflection Ihnen den Namen der aktuell ausgeführten Methode geben?

Ich neige dazu, wegen des Heisenberg-Problems nicht zu raten. Wie rufen Sie eine Methode auf, die Ihnen die aktuelle Methode anzeigt, ohne die aktuelle Methode zu ändern? Aber ich hoffe, jemand kann mir dort das Gegenteil beweisen.

Aktualisieren:

• Teil 2: Könnte dies verwendet werden, um auch im Code nach einer Eigenschaft zu suchen?
• Teil 3: Wie würde die Aufführung aussehen?

Endergebnis
Ich habe von MethodBase.GetCurrentMethod () erfahren. Ich habe auch gelernt, dass ich nicht nur einen Stack-Trace erstellen kann, sondern nur den genauen Frame erstellen kann, den ich benötige, wenn ich möchte.

Um dies in einer Eigenschaft zu verwenden, nehmen Sie einfach eine .Substring (4), um 'set_' oder 'get_' zu entfernen.

Ab .NET 4.5 können Sie auch [CallerMemberName] verwenden.

Beispiel: ein Eigenschaftssetzer (um Teil 2 zu beantworten):

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

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

Der Compiler stellt auf Callsites übereinstimmende String-Literale bereit, sodass im Grunde kein Leistungsaufwand entsteht.

Für Nicht- asyncMethoden kann man verwenden

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

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

Bitte denken Sie daran, dass für asyncMethoden "MoveNext" zurückgegeben wird.

Das von Lex bereitgestellte Snippet war etwas lang, daher weise ich auf den wichtigen Teil hin, da sonst niemand genau dieselbe Technik verwendete:

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

Dies sollte identische Ergebnisse für die MethodBase.GetCurrentMethod (). Name- Technik zurückgeben, aber es lohnt sich immer noch darauf hinzuweisen, da ich dies einmal in einer eigenen Methode implementieren könnte, indem ich Index 1 für die vorherige Methode verwende und es aus einer Reihe verschiedener Eigenschaften aufrufe. Außerdem wird nur ein Frame und nicht der gesamte Stack-Trace zurückgegeben:

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

Es ist auch ein Einzeiler;)

Versuchen Sie dies innerhalb der Main-Methode in einem leeren Konsolenprogramm:

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

Konsolenausgabe:
Main

Ja definitiv.

Wenn Sie möchten, dass ein Objekt manipuliert wird, verwende ich tatsächlich eine Funktion wie die folgende:

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

Diese Linie:

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

Geht den Stapelrahmen hoch, um die aufrufende Methode zu finden, und verwendet dann Reflection, um Parameterinformationswerte zu erhalten, die für eine generische Fehlerberichterstattungsfunktion an ihn übergeben wurden. Um die aktuelle Methode zu erhalten, verwenden Sie stattdessen einfach den aktuellen Stapelrahmen (1).

Wie andere für den aktuellen Methodennamen gesagt haben, können Sie auch Folgendes verwenden:

MethodBase.GetCurrentMethod()

Ich gehe lieber über den Stapel, weil bei interner Betrachtung dieser Methode ohnehin einfach ein StackCrawlMark erstellt wird. Die direkte Adressierung des Stapels erscheint mir klarer

Nach 4.5 können Sie jetzt das [CallerMemberNameAttribute] als Teil der Methodenparameter verwenden, um eine Zeichenfolge des Methodennamens abzurufen. Dies kann in einigen Szenarien hilfreich sein (im obigen Beispiel jedoch wirklich).

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

Dies schien hauptsächlich eine Lösung für die INotifyPropertyChanged-Unterstützung zu sein, bei der zuvor Zeichenfolgen im gesamten Ereigniscode verstreut waren.

Vergleichen von Möglichkeiten zum Abrufen des Methodennamens - Verwenden eines beliebigen Timing-Konstrukts in LinqPad:

CODE

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

ERGEBNISSE

Reflexion Reflexion

Stacktrace Stacktrace

inlineconstant inlineconstant

Konstante Konstante

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

Beachten Sie, dass die Methoden exprund callermembernicht ganz "richtig" sind. Und dort sehen Sie eine Wiederholung eines verwandten Kommentars, dass die Reflexion ~ 15x schneller ist als die Stapelverfolgung.

BEARBEITEN: MethodBase ist wahrscheinlich ein besserer Weg, um nur die Methode zu erhalten, in der Sie sich befinden (im Gegensatz zum gesamten aufrufenden Stack). Ich würde mir jedoch immer noch Sorgen um Inlining machen.

Sie können eine StackTrace innerhalb der Methode verwenden:

StackTrace st = new StackTrace(true);

Und der Blick auf die Rahmen:

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

Beachten Sie jedoch, dass Sie sich nicht in der Methode befinden, von der Sie glauben, dass Sie sie sind, wenn die Methode inline ist. Sie können ein Attribut verwenden, um Inlining zu verhindern:

[MethodImpl(MethodImplOptions.NoInlining)]

Der einfache Weg ist:

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

Wenn die System.Reflection im using-Block enthalten ist:

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

Wie wäre es damit:

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

Ich denke, Sie sollten in der Lage sein, dies durch das Erstellen eines StackTrace zu erreichen . Oder, wie @ edg und @ Lars Mæhlum erwähnen, MethodBase. GetCurrentMethod ()

Versuche dies...

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

Ich habe das gerade mit einer einfachen statischen Klasse gemacht:

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

dann in deinem 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();
        }

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