Como posso encontrar o método que chamou o método atual?

Ao efetuar logon em C #, como posso aprender o nome do método que chamou o método atual? Eu sei tudo sobre System.Reflection.MethodBase.GetCurrentMethod(), mas quero dar um passo abaixo disso no rastreamento de pilha. Eu considerei analisar o rastreamento da pilha, mas espero encontrar uma maneira mais explícita e limpa, algo como Assembly.GetCallingAssembly()mas para métodos.

Tente o seguinte:

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

uma linha:

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

É do método Get Calling usando Reflection [C #] .

No C # 5, você pode obter essas informações usando as informações do chamador :

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

Você também pode obter o [CallerFilePath]e [CallerLineNumber].

Você pode usar as informações do chamador e os parâmetros opcionais:

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

Este teste ilustra isso:

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

Enquanto o StackTrace trabalha muito rápido acima e não seria um problema de desempenho na maioria dos casos, as informações do chamador ainda são muito mais rápidas. Em uma amostra de 1000 iterações, registrei o clock 40 vezes mais rápido.

Uma rápida recapitulação das 2 abordagens, com a comparação de velocidade sendo a parte importante.

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

Determinando o chamador em tempo de compilação

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

Determinando o chamador usando a pilha

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

Comparação das 2 abordagens

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

Então você vê, usar os atributos é muito, muito mais rápido! Quase 25x mais rápido, de fato.

Podemos melhorar um pouco o código do Sr. Assad (a resposta atual aceita) instanciando apenas o quadro que realmente precisamos em vez da pilha inteira:

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

Isso pode ter um desempenho um pouco melhor, embora, com toda a probabilidade, ele ainda precise usar a pilha completa para criar esse único quadro. Além disso, ele ainda possui as mesmas ressalvas que Alex Lyman apontou (o otimizador / código nativo pode corromper os resultados). Finalmente, você pode querer verificar para ter certeza de que new StackFrame(1)ou .GetFrame(1)não voltar null, por mais improvável que essa possibilidade possa parecer.

Veja esta pergunta relacionada: Você pode usar a reflexão para encontrar o nome do método atualmente em execução?

Em geral, você pode usar a System.Diagnostics.StackTraceclasse para obter um System.Diagnostics.StackFramee, em seguida, usar o GetMethod()método para obter um System.Reflection.MethodBaseobjeto. No entanto, existem algumas ressalvas nessa abordagem:

1. Ele representa a pilha de tempo de execução - as otimizações poderiam incorporar um método e você não o verá no rastreamento da pilha.
2. Ele não mostrará nenhum quadro nativo; portanto, se houver uma chance de seu método ser chamado por um método nativo, isso não funcionará e, de fato, não há uma maneira atualmente disponível de fazê-lo.

( NOTA: Estou apenas expandindo a resposta fornecida por Firas Assad .)

A partir do .NET 4.5, você pode usar os Atributos de Informações do Chamador :

• CallerFilePath - O arquivo de origem que chamou a função;
• CallerLineNumber - Linha de código que chamou a função;

• CallerMemberName - Membro que chamou a função.

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

Esse recurso também está presente no ".NET Core" e no ".NET Standard".

Referências

1. Microsoft - Informações sobre chamadas (C #)
2. Microsoft - CallerFilePathAttributeClasse
3. Microsoft - CallerLineNumberAttributeClasse
4. Microsoft - CallerMemberNameAttributeClasse

Observe que isso não será confiável no código de liberação, devido à otimização. Além disso, a execução do aplicativo no modo sandbox (compartilhamento de rede) não permitirá que você pegue o quadro da pilha.

Considere a programação orientada a aspectos (AOP), como o PostSharp , que em vez de ser chamado pelo código, modifica o código e, portanto, sabe onde está o tempo todo.

Obviamente, esta é uma resposta tardia, mas eu tenho uma opção melhor se você pode usar o .NET 4.5 ou mais:

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

Isso imprimirá a data e hora atuais, seguidas por "Namespace.ClassName.MethodName" e terminando com ": text".
Saída de amostra:

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

Uso da amostra:

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

Talvez você esteja procurando algo parecido com isto:

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

Uma aula fantástica está aqui: http://www.csharp411.com/c-get-calling-method/

Outra abordagem que usei é adicionar um parâmetro ao método em questão. Por exemplo, em vez de void Foo(), use void Foo(string context). Em seguida, passe uma string exclusiva que indica o contexto de chamada.

Se você precisar apenas do chamador / contexto para desenvolvimento, poderá remover o paramantes do envio.

Para obter o Nome do método e o Nome da classe, tente o seguinte:

    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;

será o suficiente, eu acho.

Dê uma olhada no nome do método de log no .NET . Cuidado ao usá-lo no código de produção. O StackFrame pode não ser confiável ...

Também podemos usar lambda's para encontrar o chamador.

Suponha que você tenha um método definido por você:

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

e você quer encontrar o chamador.

1 . Altere a assinatura do método para que tenhamos um parâmetro do tipo Action (o Func também funcionará):

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

2 . Nomes Lambda não são gerados aleatoriamente. A regra parece ser:> <CallerMethodName> __X em que CallerMethodName é substituído pela função anterior e X é um índice.

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

3 . Quando chamamos MethodA, o parâmetro Action / Func deve ser gerado pelo método chamador. Exemplo:

MethodA(() => {});

4 . Dentro do MethodA agora podemos chamar a função helper definida acima e encontrar o MethodInfo do método chamador.

Exemplo:

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

Informação extra para resposta de Firas Assaad.

Eu usei new StackFrame(1).GetMethod().Name;no .net core 2.1 com injeção de dependência e estou recebendo o método de chamada como 'Iniciar'.

Eu tentei com [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" e isso me dá o método de chamada correto

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