Как мне найти метод, который вызвал текущий метод?

Попробуй это:

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

один лайнер:

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

Это от Получить метод вызова с использованием отражения [C#].

Обратите внимание, что это будет ненадежно в коде выпуска из-за оптимизации. Кроме того, запуск приложения в режиме песочницы (сетевой ресурс) вообще не позволит вам захватить фрейм стека.

Рассмотрим аспектно-ориентированное программирование (AOP), например PostSharp, который вместо того, чтобы быть вызванным из вашего кода, изменяет ваш код и, таким образом, всегда знает, где он находится.

Взгляните на Имя метода ведения журнала в .NET. Остерегайтесь использовать его в производственном коде. StackFrame может быть ненадежным ...

В общем, вы можете использовать класс System.Diagnostics.StackTrace, чтобы получить System.Diagnostics.StackFrame, а затем использовать метод GetMethod(), чтобы получить объект System.Reflection.MethodBase. Однако для этого подхода есть некоторые предостережения:

1. Он представляет стек время выполнения - оптимизации могут встроить метод, и вы увидите, что нет увидит этот метод в трассировке стека.
2. нет будет отображать любые собственные кадры, поэтому, если есть хотя бы вероятность того, что ваш метод вызывается собственным методом, это будет работать нет, и фактически в настоящее время нет доступного способа сделать это.

(ПРИМЕЧАНИЕ: я просто расширяю ответ, предоставленный Фирасом Асадом..)

Мы можем немного улучшить код Асада (текущий принятый ответ), создав экземпляр только того кадра, который нам действительно нужен, а не всего стека:

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

Это могло бы работать немного лучше, хотя, по всей вероятности, все равно придется использовать полный стек для создания этого единственного кадра. Кроме того, он по-прежнему имеет те же предостережения, которые указал Алекс Лайман (оптимизатор / собственный код могут испортить результаты). Наконец, вы можете проверить, чтобы убедиться, что new StackFrame(1) или .GetFrame(1) не возвращают null, хотя такая возможность может показаться маловероятной.

См. Этот связанный вопрос: Можете ли вы использовать отражение, чтобы найти имя выполняемого в данный момент метода?

Может быть, вы ищете что-то вроде этого:

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

Другой подход, который я использовал, - это добавление параметра к рассматриваемому методу. Например, вместо void Foo() используйте void Foo(string context). Затем передайте некоторую уникальную строку, которая указывает контекст вызова.

Если вам нужен только вызывающий / контекст для разработки, вы можете удалить param перед отправкой.

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

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

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

Фантастический класс здесь: http://www.csharp411.com/c-get-calling-method/

В C# 5 эту информацию можно получить с помощью информация о вызывающем абоненте:

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

Вы также можете получить [CallerFilePath] и [CallerLineNumber].

Вы можете использовать информацию о вызывающем абоненте и дополнительные параметры:

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

Этот тест иллюстрирует это:

[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 выше работает довольно быстро и не будет проблемой для производительности, в большинстве случаев информация о вызывающем абоненте все же намного быстрее. В выборке из 1000 итераций я работал в 40 раз быстрее.

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

Думаю, хватит.

Мы также можем использовать лямбда-выражения, чтобы найти вызывающего.

Предположим, у вас есть определенный вами метод:

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

и вы хотите найти его абонента.

1. Измените подпись метода, чтобы у нас был параметр типа Action (Func также будет работать):

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

2. Лямбда-имена не генерируются случайным образом. Правило выглядит так:> <CallerMethodName> __X где CallerMethodName заменяется предыдущей функцией, а X - индекс.

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

3. Когда мы вызываем MethodA, параметр Action / Func должен быть сгенерирован вызывающим методом. Пример:

MethodA(() => {});

4. Теперь внутри MethodA мы можем вызвать вспомогательную функцию, определенную выше, и найти MethodInfo вызывающего метода.

Пример:

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

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

Начиная с .NET 4.5, вы можете использовать атрибуты Информация о вызывающем абоненте:

• CallerFilePath - исходный файл, который вызвал функцию;
• CallerLineNumber - Строка кода, которая вызвала функцию;

• CallerMemberName - член, который вызвал функцию.

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

Эта возможность также присутствует в .NET Core и .NET Standard.

использованная литература

1. Microsoft - информация о вызывающем абоненте (C#)
2. Microsoft - класс CallerFilePathAttribute
3. Microsoft - класс CallerLineNumberAttribute
4. Microsoft - класс CallerMemberNameAttribute

Краткий обзор двух подходов, важная часть которых - сравнение скорости.

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

Определение вызывающей стороны во время компиляции

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

Определение вызывающего абонента с помощью стека

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

Сравнение двух подходов

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

So you see, using the attributes is much, much faster! Nearly 25x faster in fact.

Очевидно, это поздний ответ, но у меня есть лучший вариант, если вы можете использовать .NET 4.5 или новее:

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

Будет напечатана текущая дата и время, за которыми следуют «Namespace.ClassName.MethodName» и заканчиваются на «: text» .
Пример вывода:

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

Пример использования:

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

Чтобы получить имя метода и имя класса, попробуйте следующее:

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

Дополнительная информация к ответу Фираса Ассаада.

Я использовал new StackFrame(1).GetMethod().Name; в .net core 2.1 с внедрением зависимостей, и я получаю метод вызова как «Пуск».

Пробовал с [System.Runtime.CompilerServices.CallerMemberName] string callerName = "" и это дает мне правильный метод вызова