Jak znaleźć metodę, która wywołała bieżącą metodę?

Jak zalogować się w języku C #, jak mogę poznać nazwę metody, która wywołała bieżącą metodę? Wiem wszystko System.Reflection.MethodBase.GetCurrentMethod(), ale chcę przejść o krok dalej w śladzie stosu. Zastanawiałem się nad parsowaniem śladu stosu, ale mam nadzieję znaleźć bardziej przejrzysty sposób, coś w rodzaju Assembly.GetCallingAssembly()metod.

Spróbuj tego:

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

jednowarstwowy:

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

Pochodzi z metody Get Calling Method przy użyciu Reflection [C #] .

W C # 5 możesz uzyskać te informacje za pomocą informacji o dzwoniącym :

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

Możesz także uzyskać [CallerFilePath]i [CallerLineNumber].

Możesz użyć informacji o dzwoniącym i opcjonalnych parametrów:

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

Ten test ilustruje to:

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

Chociaż StackTrace działa dość szybko powyżej i w większości przypadków nie będzie to problem z wydajnością, informacje o dzwoniącym są nadal znacznie szybsze. W próbce 1000 iteracji taktowałem ją 40 razy szybciej.

Szybkie podsumowanie 2 podejść, przy czym ważnym elementem jest porównanie prędkości.

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

Określanie dzwoniącego w czasie kompilacji

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

Określanie dzwoniącego za pomocą stosu

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

Porównanie dwóch podejść

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

Widzisz, używanie atrybutów jest znacznie, dużo szybsze! Prawie 25 razy szybszy.

Możemy nieco ulepszyć kod pana Assada (obecna akceptowana odpowiedź), tworząc tylko potrzebną ramkę, a nie cały stos:

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

Może to działać nieco lepiej, choć najprawdopodobniej nadal musi użyć pełnego stosu, aby utworzyć tę pojedynczą ramkę. Ponadto nadal ma te same zastrzeżenia, które wskazał Alex Lyman (optymalizator / kod natywny może uszkodzić wyniki). Wreszcie możesz sprawdzić, aby upewnić się, że nie , new StackFrame(1)lub .GetFrame(1)nie powrócić null, tak mało prawdopodobne, jak mogłoby się wydawać.

Zobacz to pokrewne pytanie: czy możesz użyć refleksji, aby znaleźć nazwę aktualnie wykonywanej metody?

Ogólnie rzecz biorąc, możesz użyć System.Diagnostics.StackTraceklasy, aby uzyskać a System.Diagnostics.StackFrame, a następnie użyć GetMethod()metody, aby uzyskać System.Reflection.MethodBaseobiekt. Istnieją jednak pewne zastrzeżenia dotyczące tego podejścia:

1. Reprezentuje stos środowiska wykonawczego - optymalizacje mogłyby wstawić metodę i nie zobaczysz tej metody w śladzie stosu.
2. To będzie nie wykazują żadnych rodzimych ramek, więc jeśli jest nawet szansa metoda jest wywoływana przez native metody, będzie to nie praca, i nie będzie już w rzeczywistości nie ma obecnie dostępny sposób to zrobić.

( UWAGA: Właśnie rozwijam odpowiedź udzieloną przez Firas Assad .)

Począwszy od .NET 4.5 można używać atrybutów informacji o dzwoniącym :

• CallerFilePath - Plik źródłowy, który wywołał funkcję;
• CallerLineNumber - Wiersz kodu, który wywołał funkcję;

• CallerMemberName - Członek, który wywołał funkcję.

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

Ta funkcja jest również dostępna w „.NET Core” i „.NET Standard”.

Bibliografia

1. Microsoft - informacje o dzwoniącym (C #)
2. Microsoft - CallerFilePathAttributeklasa
3. Microsoft - CallerLineNumberAttributeklasa
4. Microsoft - CallerMemberNameAttributeklasa

Pamiętaj, że takie postępowanie będzie niewiarygodne w kodzie wersji ze względu na optymalizację. Ponadto uruchomienie aplikacji w trybie piaskownicy (udział sieciowy) w ogóle nie pozwala na uchwycenie ramki stosu.

Zastanów się nad programowaniem aspektowym (AOP), takim jak PostSharp , który zamiast być wywoływany z kodu, modyfikuje kod, a tym samym wie, gdzie on jest.

Oczywiście jest to późna odpowiedź, ale mam lepszą opcję, jeśli możesz używać .NET 4.5 lub więcej:

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

Spowoduje to wydrukowanie bieżącej daty i godziny, a następnie „Namespace.ClassName.MethodName” i kończące się na „: text”.
Przykładowe dane wyjściowe:

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

Przykładowe użycie:

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

Może szukasz czegoś takiego:

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

Fantastyczna klasa jest tutaj: http://www.csharp411.com/c-get-calling-method/

Innym podejściem, które zastosowałem, jest dodanie parametru do metody, o której mowa. Na przykład zamiast void Foo()użyj void Foo(string context). Następnie przekaż unikalny ciąg znaków, który wskazuje kontekst wywołania.

Jeśli potrzebujesz tylko dzwoniącego / kontekstu do opracowania, możesz usunąć paramprzed wysyłką.

Aby uzyskać nazwę metody i nazwę klasy, spróbuj:

    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;

myślę, że wystarczy.

Spójrz na nazwę metody rejestrowania w .NET . Uwaga na używanie go w kodzie produkcyjnym. StackFrame może nie być wiarygodny ...

Możemy również użyć lambda do znalezienia dzwoniącego.

Załóżmy, że masz zdefiniowaną przez siebie metodę:

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

i chcesz znaleźć dzwoniącego.

1 . Zmień podpis metody, abyśmy mieli parametr typu Action (Func również będzie działał):

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

2 . Nazwy Lambda nie są generowane losowo. Reguła wydaje się wyglądać następująco:> <nazwa_programu_wywołania> __X, gdzie nazwa_wywołania jest zastępowana przez poprzednią funkcję, a X to indeks.

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

3 . Kiedy wywołujemy MethodA, parametr Action / Func musi zostać wygenerowany przez metodę wywołującą. Przykład:

MethodA(() => {});

4 . Wewnątrz MethodA możemy teraz wywołać funkcję pomocniczą zdefiniowaną powyżej i znaleźć MethodInfo metody wywołującej.

Przykład:

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

Dodatkowe informacje do odpowiedzi Firas Assaad.

Użyłem new StackFrame(1).GetMethod().Name;w .net core 2.1 z iniekcją zależności i otrzymuję metodę wywoływania jako „Start”.

Próbowałem z [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" i daje mi to prawidłową metodę wywoływania

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