Bisakah Anda menggunakan refleksi untuk menemukan nama metode yang sedang dijalankan?

Seperti judulnya katakan: Dapatkah refleksi memberi Anda nama metode yang sedang dijalankan.

Saya cenderung tidak menebak, karena masalah Heisenberg. Bagaimana Anda memanggil metode yang akan memberi tahu Anda metode saat ini tanpa mengubah apa metode saat ini? Tapi saya berharap seseorang bisa membuktikan saya salah di sana.

Memperbarui:

• Bagian 2: Bisakah ini digunakan untuk mencari kode di dalam properti juga?
• Bagian 3: Seperti apa performanya?

Hasil Akhir yang
saya pelajari tentang MethodBase.GetCurrentMethod (). Saya juga belajar bahwa saya tidak hanya dapat membuat jejak stack, saya hanya dapat membuat frame persis yang saya butuhkan jika saya mau.

Untuk menggunakan ini di dalam properti, cukup ambil. Substring (4) untuk menghapus 'set_' atau 'get_'.

Pada .NET 4.5 Anda juga dapat menggunakan [CallerMemberName]

Contoh: penyetel properti (untuk menjawab bagian 2):

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

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

Compiler akan menyediakan string literal yang cocok di callsites, jadi pada dasarnya tidak ada overhead kinerja.

Untuk non- asyncmetode, seseorang dapat menggunakan

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

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

Harap diingat bahwa untuk asyncmetode ini akan mengembalikan "MoveNext".

Cuplikan yang disediakan oleh Lex agak panjang, jadi saya menunjukkan bagian penting karena tidak ada orang lain yang menggunakan teknik yang sama persis:

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

Ini harus mengembalikan hasil yang identik ke MethodBase.GetCurrentMethod (). Teknik nama , tapi masih layak untuk ditunjukkan karena saya bisa menerapkan ini sekali dalam metode sendiri menggunakan indeks 1 untuk metode sebelumnya dan memanggilnya dari sejumlah properti yang berbeda. Selain itu, ia hanya mengembalikan satu frame ketimbang seluruh jejak tumpukan:

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

Ini juga satu kalimat;)

Coba ini di dalam metode Utama di program konsol kosong:

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

Output Konsol:
Main

Iya tentu saja.

Jika Anda ingin memanipulasi objek, saya sebenarnya menggunakan fungsi seperti ini:

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

Garis ini:

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

Menaiki bingkai tumpukan untuk menemukan metode pemanggilan kemudian kami menggunakan refleksi untuk mendapatkan nilai informasi parameter yang diteruskan ke sana untuk fungsi pelaporan kesalahan umum. Untuk mendapatkan metode saat ini, cukup gunakan bingkai tumpukan saat ini (1).

Seperti yang orang lain katakan untuk nama metode saat ini, Anda juga dapat menggunakan:

MethodBase.GetCurrentMethod()

Saya lebih suka berjalan stack karena jika melihat secara internal pada metode itu hanya menciptakan StackCrawlMark. Mengatasi Stack secara langsung tampak lebih jelas bagi saya

Posting 4.5 Anda sekarang dapat menggunakan [CallerMemberNameAttribute] sebagai bagian dari parameter metode untuk mendapatkan string dari nama metode - ini dapat membantu dalam beberapa skenario (tetapi benar-benar mengatakan contoh di atas)

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

Ini tampaknya terutama solusi untuk dukungan INotifyPropertyChanged di mana sebelumnya Anda memiliki string yang berserakan di seluruh kode acara Anda.

Membandingkan cara untuk mendapatkan nama metode - menggunakan konstruk pewaktuan arbitrer di LinqPad:

KODE

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

HASIL

refleksi refleksi

stacktrace stacktrace

inlineconstant inlineconstant

konstan konstan

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

Perhatikan bahwa exprdan callermembermetode tidak "benar". Dan di sana Anda melihat pengulangan dari komentar terkait bahwa refleksi ~ 15x lebih cepat dari stacktrace.

EDIT: MethodBase mungkin merupakan cara yang lebih baik untuk mendapatkan metode yang Anda gunakan (sebagai lawan dari keseluruhan tumpukan panggilan). Saya masih khawatir tentang inlining.

Anda dapat menggunakan StackTrace dalam metode:

StackTrace st = new StackTrace(true);

Dan lihat pada bingkai:

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

Namun, ketahuilah bahwa jika metode ini sebaris, Anda tidak akan berada di dalam metode yang Anda pikirkan. Anda bisa menggunakan atribut untuk mencegah inlining:

[MethodImpl(MethodImplOptions.NoInlining)]

Cara sederhana untuk bertransaksi adalah:

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

Jika System.Reflection termasuk dalam blok using:

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

Bagaimana dengan ini:

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

Saya pikir Anda harus bisa mendapatkannya dari membuat StackTrace . Atau, seperti yang disebutkan @ edg dan @ Lars Mæhlum , MethodBase. GetCurrentMethod ()

Coba ini...

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

Saya hanya melakukan ini dengan kelas statis sederhana:

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

lalu dalam kode Anda:

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()