如何找到称为当前方法的方法？

Question

登录C＃时，如何学习称为当前方法的方法的名称？我对 System.Reflection.Methodbase.getCurrentMethod（）了解全部了解，但是我想在堆栈跟踪中走一步。我已经考虑过解析堆栈跟踪，但是我希望找到一种更清洁的方法，例如 assembly.getCallingAssembly（） ，但用于方法。

Answer 1

尝试一下：

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

Answer 2

在C＃5中，您可以使用 caller信息：

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

您还可以获取 [CallerFilePath] 和 [CallerlineNumber] 。

Answer 3

您可以使用呼叫者信息和可选参数：

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(nameof(Should_get_name_of_calling_method)));
}

虽然stacktrace的工作原理很快，并且在大多数情况下，呼叫者信息的速度仍然更快。在1000次迭代的样本中，我将其计入了40倍的速度。

Answer 4

与速度比较的快速回顾是重要的部分。

档案/2013/07/25/c.net-little-tilter-getting-getting-caller-information.aspx

在compile time

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

因此，您会看到，使用属性要快得多！将近25倍
实际上，更快。

Answer 5

我们可以通过仅实例化我们实际需要的框架而不是整个堆栈来改进阿萨德先生的代码（当前接受的答案）：

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

这可能会更好，尽管很可能仍然必须使用完整的堆栈创建该单一帧。此外，它仍然具有与Alex Lyman指出的相同的警告（优化器/本机代码可能会损坏结果）。最后，您可能需要检查以确保新的StackFrame（1）或 .getFrame（1）否返回 null ，as这种可能性似乎不太可能。

请参阅此相关问题：
您可以使用反射来找到当前执行方法的名称？

Answer 6

通常，您可以使用 system.diarostics.diarostics.diarostics.stacktrace.stacktrace 类要获得 system.diagnostics.stackframe ，然后使用 getMethod（） 获得 system.reflection.methodbase 对象。但是，有一些警告对这种方法

1. ：代表运行时堆栈 - 优化可能会嵌入方法，并且您将 不是 请参阅堆栈跟踪中的该方法。
2. 它将 不是 显示任何本地框架，因此，如果您的方法通过本机方法调用，这将是 而不是 工作，并且目前没有可用的方法可以做到这一点。

（注意：我只是在扩展答案 Firas Assad提供的答案）。

Answer 7

在.NET 4.5开始时，您可以使用“ noreferrer”>来电者信息属性：

• CallerFilePath - 称为函数的源文件；

• - 称为函数的成员。

    public void Writeline（
      [CallerFilePath]字符串CallerFilePath =“”， 
      [CallerlineNumber]长CallerlineNumber = 0，
      [callermembername]字符串callermember =“”）
  {
      debug.writeline（
          “呼叫者文件路径：{0}，呼叫者行号：{1}，呼叫者成员：{2}”， 
          Callerfilepath，
          CallerlineNumber，
          callermember）;
  }
   

＆nbsp;

该设施也存在于“ .NET Core”和“ .NET标准”中。

参考

2. 类
3. CallerlineNumberattribute class
4. callermemberneattribute class

Answer 8

显然，这是一个较晚的答案，但是如果您可以使用.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”结尾。 br>
样本输出：

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

样本使用：

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

Answer 9

请注意，由于优化，这样做在发行代码中是不可靠的。此外，以沙盒模式运行应用程序（网络共享）不允许您完全抓住堆栈框架。

考虑“ noreferrer”> tockent-opent-opiented编程（aop），例如 postsharp ，它没有从代码中调用，而是修改代码，从而知道始终在哪里。

Answer 10

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

Answer 11

也许您正在寻找这样的东西：

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

Answer 12

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-get-呼叫方法/

Answer 13

要获得方法名称和班级名称，请尝试以下操作：

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

Answer 14

我使用的另一种方法是将参数添加到所讨论的方法中。例如，代替 void foo（），使用 void foo（字符串上下文）。然后传递一些指示调用上下文的唯一字符串。

如果您只需要呼叫者/上下文进行开发，则可以在运输前删除 param 。

Answer 15

额外的信息给firas assaad答案。

我已经使用新的stackframe（1）.getMethod（）。名称; in .net core 2.1带有依赖项注入，并且我将调用方法作为“ start”。

我尝试了 [System.Runtime.compilerServices.callermembername]字符串callername =“”
它给了我正确的呼叫方法

Answer 16

我们还可以使用lambda的目的来找到呼叫者。

假设您有一种定义的方法：

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

您想找到它的呼叫者。

1 。更改方法签名，以便我们具有类型动作的参数（func也将起作用）：

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

2 。 lambda名称不是随机生成的。该规则似乎是：＆gt; ＆lt; callermethodname＆gt; __ x
callermethodname被以前的函数替换，而x是索引。

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

3 。当我们调用Methoda时，必须通过呼叫者方法生成操作/弹性参数。
示例：

MethodA(() => {});

4 。在Methoda内部，我们可以调用上面定义的辅助函数，并找到呼叫者方法的方法。

例子：

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

Answer 17

public static string GetCallerFullName<T>(this T callingObject,[CallerMemberName] string caller = default) =>$"{callingObject.GetType().Name}:{caller}";

这是对 Camilo Terevinto的解决方案的略有改进

this.GetCallerFullName();