Bagaimana saya dapat menemukan metode yang disebut metode saat ini?

Saat masuk C #, bagaimana saya bisa mempelajari nama metode yang disebut metode saat ini? Saya tahu semua tentang System.Reflection.MethodBase.GetCurrentMethod(), tetapi saya ingin pergi satu langkah di bawah ini di jejak tumpukan. Saya telah mempertimbangkan untuk mengurai jejak stack, tetapi saya berharap untuk menemukan cara yang lebih bersih dan lebih eksplisit, seperti Assembly.GetCallingAssembly()tetapi untuk metode.

Coba ini:

using System.Diagnostics;
// Get call stack
StackTrace stackTrace = new StackTrace(); 
// Get calling method name
Console.WriteLine(stackTrace.GetFrame(1).GetMethod().Name);

satu garis:

(new System.Diagnostics.StackTrace()).GetFrame(1).GetMethod().Name

Itu dari Get Calling Method menggunakan Reflection [C #] .

Di C # 5 Anda bisa mendapatkan informasi itu menggunakan info penelepon :

//using System.Runtime.CompilerServices;
public void SendError(string Message, [CallerMemberName] string callerName = "") 
{ 
    Console.WriteLine(callerName + "called me."); 
} 

Anda juga bisa mendapatkan [CallerFilePath]dan [CallerLineNumber].

Anda dapat menggunakan Informasi Penelepon dan parameter opsional:

public static string WhoseThere([CallerMemberName] string memberName = "")
{
       return memberName;
}

Tes ini menggambarkan hal ini:

[Test]
public void Should_get_name_of_calling_method()
{
    var methodName = CachingHelpers.WhoseThere();
    Assert.That(methodName, Is.EqualTo("Should_get_name_of_calling_method"));
}

Sementara StackTrace bekerja sangat cepat di atas dan tidak akan menjadi masalah kinerja dalam banyak kasus, Informasi Penelepon masih jauh lebih cepat. Dalam sampel 1000 iterasi, saya mencatatnya 40 kali lebih cepat.

Rekap cepat dari 2 pendekatan dengan perbandingan kecepatan menjadi bagian penting.

http://geekswithblogs.net/BlackRabbitCoder/archive/2013/07/25/c.net-little-wonders-getting-caller-information.aspx

Menentukan penelepon pada waktu kompilasi

static void Log(object message, 
[CallerMemberName] string memberName = "",
[CallerFilePath] string fileName = "",
[CallerLineNumber] int lineNumber = 0)
{
    // we'll just use a simple Console write for now    
    Console.WriteLine("{0}({1}):{2} - {3}", fileName, lineNumber, memberName, message);
}

Menentukan penelepon menggunakan tumpukan

static void Log(object message)
{
    // frame 1, true for source info
    StackFrame frame = new StackFrame(1, true);
    var method = frame.GetMethod();
    var fileName = frame.GetFileName();
    var lineNumber = frame.GetFileLineNumber();

    // we'll just use a simple Console write for now    
    Console.WriteLine("{0}({1}):{2} - {3}", fileName, lineNumber, method.Name, message);
}

Perbandingan kedua pendekatan tersebut

Time for 1,000,000 iterations with Attributes: 196 ms
Time for 1,000,000 iterations with StackTrace: 5096 ms

Jadi Anda tahu, menggunakan atribut jauh, jauh lebih cepat! Nyaris 25x lebih cepat sebenarnya.

Kita dapat memperbaiki kode Mr Assad (jawaban yang diterima saat ini) hanya sedikit dengan membuat instance hanya frame yang sebenarnya kita butuhkan daripada seluruh tumpukan:

new StackFrame(1).GetMethod().Name;

Ini mungkin melakukan sedikit lebih baik, meskipun kemungkinan masih harus menggunakan tumpukan penuh untuk membuat bingkai tunggal itu. Juga, itu masih memiliki peringatan yang sama yang ditunjukkan oleh Alex Lyman (pengoptimal / kode asli mungkin merusak hasil). Akhirnya, Anda mungkin ingin memeriksa untuk memastikannya new StackFrame(1)atau .GetFrame(1)tidak kembalinull , tidak mungkin seperti kemungkinan itu muncul.

Lihat pertanyaan terkait ini: Dapatkah Anda menggunakan refleksi untuk menemukan nama metode yang sedang dijalankan?

Secara umum, Anda bisa menggunakan System.Diagnostics.StackTracekelas untuk mendapatkan System.Diagnostics.StackFrame, dan kemudian menggunakan GetMethod()metode untuk mendapatkan System.Reflection.MethodBaseobjek. Namun, ada beberapa peringatan untuk pendekatan ini:

1. Itu mewakili tumpukan runtime - optimisasi bisa sebaris metode, dan Anda tidak akan melihat metode itu di jejak tumpukan.
2. Ini tidak akan menampilkan bingkai asli apa pun, jadi jika ada kemungkinan metode Anda dipanggil oleh metode asli, ini tidak akan berfungsi, dan sebenarnya tidak ada cara yang tersedia saat ini untuk melakukannya.

( CATATAN: Saya hanya memperluas jawaban yang diberikan oleh Firas Assad .)

Pada. NET 4.5 Anda dapat menggunakan Atribut Informasi Penelepon :

• CallerFilePath - File sumber yang disebut fungsi;
• CallerLineNumber - Baris kode yang disebut fungsi;

• CallerMemberName - Anggota yang memanggil fungsi.

  public void WriteLine(
      [CallerFilePath] string callerFilePath = "", 
      [CallerLineNumber] long callerLineNumber = 0,
      [CallerMemberName] string callerMember= "")
  {
      Debug.WriteLine(
          "Caller File Path: {0}, Caller Line Number: {1}, Caller Member: {2}", 
          callerFilePath,
          callerLineNumber,
          callerMember);
  }

Fasilitas ini juga hadir dalam ".NET Core" dan ".NET Standard".

Referensi

1. Microsoft - Informasi Penelepon (C #)
2. Microsoft - CallerFilePathAttributeKelas
3. Microsoft - CallerLineNumberAttributeKelas
4. Microsoft - CallerMemberNameAttributeKelas

Perhatikan bahwa hal itu tidak akan dapat diandalkan dalam kode rilis, karena optimasi. Selain itu, menjalankan aplikasi dalam mode kotak pasir (berbagi jaringan) tidak akan memungkinkan Anda untuk mengambil bingkai tumpukan sama sekali.

Pertimbangkan pemrograman berorientasi aspek (AOP), seperti PostSharp , yang alih-alih dipanggil dari kode Anda, memodifikasi kode Anda, dan karenanya tahu di mana ia berada setiap saat.

Jelas ini adalah jawaban yang terlambat, tetapi saya memiliki pilihan yang lebih baik jika Anda dapat menggunakan .NET 4.5 atau lebih:

internal static void WriteInformation<T>(string text, [CallerMemberName]string method = "")
{
    Console.WriteLine(DateTime.Now.ToString() + " => " + typeof(T).FullName + "." + method + ": " + text);
}

Ini akan mencetak Tanggal dan Waktu saat ini, diikuti oleh "Namespace.ClassName.MethodName" dan diakhiri dengan ": teks".
Output sampel:

6/17/2016 12:41:49 PM => WpfApplication.MainWindow..ctor: MainWindow initialized

Penggunaan sampel:

Logger.WriteInformation<MainWindow>("MainWindow initialized");

/// <summary>
/// Returns the call that occurred just before the "GetCallingMethod".
/// </summary>
public static string GetCallingMethod()
{
   return GetCallingMethod("GetCallingMethod");
}

/// <summary>
/// Returns the call that occurred just before the the method specified.
/// </summary>
/// <param name="MethodAfter">The named method to see what happened just before it was called. (case sensitive)</param>
/// <returns>The method name.</returns>
public static string GetCallingMethod(string MethodAfter)
{
   string str = "";
   try
   {
      StackTrace st = new StackTrace();
      StackFrame[] frames = st.GetFrames();
      for (int i = 0; i < st.FrameCount - 1; i++)
      {
         if (frames[i].GetMethod().Name.Equals(MethodAfter))
         {
            if (!frames[i + 1].GetMethod().Name.Equals(MethodAfter)) // ignores overloaded methods.
            {
               str = frames[i + 1].GetMethod().ReflectedType.FullName + "." + frames[i + 1].GetMethod().Name;
               break;
            }
         }
      }
   }
   catch (Exception) { ; }
   return str;
}

Mungkin Anda mencari sesuatu seperti 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

private static MethodBase GetCallingMethod()
{
  return new StackFrame(2, false).GetMethod();
}

private static Type GetCallingType()
{
  return new StackFrame(2, false).GetMethod().DeclaringType;
}

Kelas yang fantastis ada di sini: http://www.csharp411.com/c-get-calling-method/

Pendekatan lain yang saya gunakan adalah menambahkan parameter ke metode yang dimaksud. Misalnya, alih-alih void Foo(), gunakan void Foo(string context). Kemudian masukkan beberapa string unik yang menunjukkan konteks panggilan.

Jika Anda hanya membutuhkan penelepon / konteks untuk pengembangan, Anda dapat menghapus paramsebelum pengiriman.

Untuk mendapatkan Nama Metode dan Nama Kelas coba ini:

    public static void Call()
    {
        StackTrace stackTrace = new StackTrace();

        var methodName = stackTrace.GetFrame(1).GetMethod();
        var className = methodName.DeclaringType.Name.ToString();

        Console.WriteLine(methodName.Name + "*****" + className );
    }

StackFrame caller = (new System.Diagnostics.StackTrace()).GetFrame(1);
string methodName = caller.GetMethod().Name;

akan cukup, saya pikir.

Lihatlah nama metode Logging di .NET . Waspadalah menggunakannya dalam kode produksi. StackFrame mungkin tidak dapat diandalkan ...

Kita juga dapat menggunakan lambda untuk menemukan penelepon.

Misalkan Anda memiliki metode yang ditentukan oleh Anda:

public void MethodA()
    {
        /*
         * Method code here
         */
    }

dan Anda ingin menemukan itu penelepon.

1 . Ubah tanda tangan metode sehingga kami memiliki parameter tipe Action (Func juga akan berfungsi):

public void MethodA(Action helperAction)
        {
            /*
             * Method code here
             */
        }

2 . Nama Lambda tidak dihasilkan secara acak. Aturannya tampaknya:> <CallerMethodName> __X di mana CallerMethodName digantikan oleh fungsi sebelumnya dan X adalah indeks.

private MethodInfo GetCallingMethodInfo(string funcName)
    {
        return GetType().GetMethod(
              funcName.Substring(1,
                                funcName.IndexOf(">", 1, StringComparison.Ordinal) - 1)
              );
    }

3 . Ketika kita memanggil MethodA, parameter Action / Func harus dihasilkan oleh metode pemanggil. Contoh:

MethodA(() => {});

4 . Di dalam MethodA kita sekarang dapat memanggil fungsi helper yang didefinisikan di atas dan menemukan MethodInfo dari metode pemanggil.

Contoh:

MethodInfo callingMethodInfo = GetCallingMethodInfo(serverCall.Method.Name);

Informasi tambahan untuk jawaban Firas Assaad.

Saya telah menggunakan new StackFrame(1).GetMethod().Name;.net core 2.1 dengan injeksi ketergantungan dan saya mendapatkan metode panggilan sebagai 'Mulai'.

Saya mencoba [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" dan itu memberi saya metode panggilan yang benar

var callingMethod = new StackFrame(1, true).GetMethod();
string source = callingMethod.ReflectedType.FullName + ": " + callingMethod.Name;