Geçerli yöntemi çağıran yöntemi nasıl bulabilirim?

C # 'a giriş yaparken, geçerli yöntemi çağıran yöntemin adını nasıl öğrenebilirim? Her şeyi biliyorum System.Reflection.MethodBase.GetCurrentMethod(), ama yığın izinde bunun bir adım altına gitmek istiyorum. Yığın izini ayrıştırmayı düşündüm, ancak daha temiz bir yol bulmayı umuyorum, Assembly.GetCallingAssembly()yöntemler gibi ama.

Bunu dene:

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

tek satırlık:

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

Bu dan al yansıma [C #] kullanarak yöntemi çağırma .

C # 5'te arayan bilgilerini kullanarak bu bilgileri alabilirsiniz :

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

Ayrıca [CallerFilePath]ve alabilirsiniz [CallerLineNumber].

Arayan Bilgilerini ve isteğe bağlı parametreleri kullanabilirsiniz:

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

Bu test bunu göstermektedir:

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

StackTrace yukarıda oldukça hızlı çalışmasına rağmen, çoğu durumda Arayan Bilgileri çok daha hızlıdır. 1000 yinelemeden oluşan bir örnekte, bunu 40 kat daha hızlı izledim.

Hız yaklaşımının önemli bir parçası olduğu 2 yaklaşımın hızlı bir özeti.

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

Arayanın derleme zamanında belirlenmesi

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

Yığını kullanarak arayanı belirleme

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

2 yaklaşımın karşılaştırılması

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

Gördüğünüz gibi, öznitelikleri kullanmak çok daha hızlı! Aslında yaklaşık 25 kat daha hızlı.

Bay Assad'ın kodunu (şu anki kabul edilen cevap), tüm yığının yerine sadece ihtiyacımız olan çerçeveyi somutlaştırarak biraz geliştirebiliriz:

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

Bu biraz daha iyi performans gösterebilir, ancak her durumda, o tek kareyi oluşturmak için tam yığını kullanması gerekir. Ayrıca, Alex Lyman'ın belirttiği aynı uyarılar hala var (optimize edici / yerel kod sonuçları bozabilir). Son olarak, bu olasılığın göründüğü kadar olası olmadığından emin olmak new StackFrame(1)veya .GetFrame(1)geri dönmemek için kontrol etmek nullisteyebilirsiniz.

Bu ilgili soruya bakın: Şu anda yürütülen yöntemin adını bulmak için yansıma kullanabilir misiniz?

Genel olarak, System.Diagnostics.StackTracesınıfı a almak için System.Diagnostics.StackFramekullanabilir ve sonra nesneyi GetMethod()almak için yöntemi kullanabilirsiniz System.Reflection.MethodBase. Bununla birlikte, bu yaklaşımın bazı uyarıları vardır :

1. Bu temsil çalışma zamanı yığını - optimizasyonlar bir yöntemi satır içi olabilir ve bundan olacak değil yığın izlemesinde bu yöntemi görüyoruz.
2. Bu olacak değil senin yöntem bir yerli yöntemle çağrılan bir şans, bu irade bile var eğer öyleyse, herhangi bir yerel çerçeveleri göstermek değil iş ve aslında içinde bunu yapmak için mevcut yolu henüz geliştirilememiştir.

( NOT: Sadece Firas Esad'ın verdiği cevabı genişletiyorum .)

.NET 4.5'ten itibaren Arayan Bilgisi Özniteliklerini kullanabilirsiniz :

• CallerFilePath - İşlevi çağıran kaynak dosya;
• CallerLineNumber - Fonksiyon olarak adlandırılan kod satırı;

• CallerMemberName - İşlevi çağıran üye.

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

Bu özellik ".NET Core" ve ".NET Standard" da da mevcuttur.

Referanslar

1. Microsoft - Arayan Bilgisi (C #)
2. Microsoft - CallerFilePathAttributeSınıf
3. Microsoft - CallerLineNumberAttributeSınıf
4. Microsoft - CallerMemberNameAttributeSınıf

Bunu yapmanın optimizasyon nedeniyle yayın kodunda güvenilir olmayacağını unutmayın. Ayrıca, uygulamayı korumalı alan modunda (ağ paylaşımı) çalıştırmak yığın çerçevesini yakalamanıza izin vermez.

PostSharp gibi , kodunuzdan çağrılmak yerine kodunuzu değiştiren ve böylece her zaman nerede olduğunu bilen en boy yönelimli programlamayı (AOP) düşünün .

Açıkçası bu geç bir cevaptır, ancak .NET 4.5 veya daha fazlasını kullanabiliyorsanız daha iyi bir seçeneğim var:

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

Bu işlem geçerli Tarih ve Saati, ardından "Namespace.ClassName.MethodName" ve ": text" ile biter.
Örnek çıktı:

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

Örnek kullanım:

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

Belki böyle bir şey arıyorsunuz:

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

Harika bir sınıf burada: http://www.csharp411.com/c-get-calling-method/

Kullandığım başka bir yaklaşım, söz konusu yönteme bir parametre eklemektir. Örneğin, yerine void Foo(), kullanımıvoid Foo(string context) . Ardından çağıran bağlamı gösteren benzersiz bir dize iletin.

Gelişim için yalnızca arayan / bağlama ihtiyacınız varsa, paramgöndermeden önce kaldırabilirsiniz .

Yöntem Adı ve Sınıf Adı almak için şunu deneyin:

    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;

bence yeterli olacak.

.NET'te Günlüğe kaydetme yöntemi adına bir göz atın . Üretim kodunda kullanmaya dikkat edin. StackFrame güvenilir olmayabilir ...

Arayanı bulmak için lambda'yı da kullanabiliriz.

Sizin tanımladığınız bir yönteminiz olduğunu varsayalım:

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

ve arayanı bulmak istiyorsun.

1 . Eylem türünde bir parametrenin olması için yöntem imzasını değiştirin (Func da çalışır):

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

2 . Lambda adları rastgele oluşturulmaz. Kural şöyledir:> <CallerMethodName> __X Burada CallerMethodName, önceki işlevle değiştirilir ve X, bir dizindir.

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

3 . MethodA'yı çağırdığımızda, Action / Func parametresi, arayan yöntemi tarafından oluşturulmalıdır. Misal:

MethodA(() => {});

4 . Şimdi, yukarıda tanımlanan yardımcı işlevi çağırabilir ve arayan yönteminin MethodInfo'yu bulabiliriz.

Misal:

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

Firas Assaad cevabına ek bilgi.

Ben kullandım new StackFrame(1).GetMethod().Name;bağımlılık enjeksiyonu ile .net çekirdek 2.1 ve ben 'Başlat' olarak çağıran yöntemini alıyorum.

Ben denedim [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" ve bana doğru arama yöntemi verir

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