您可以使用反射来查找当前正在执行的方法的名称吗？

如标题所示：反射可以为您提供当前正在执行的方法的名称。

由于海森堡问题，我倾向于不猜测。您如何调用一个方法，该方法将告诉您当前方法而不更改当前方法是什么？但我希望有人能证明我做错了。

更新：

• 第2部分：是否可以将其用于查找属性的内部代码？
• 第3部分：演出效果如何？

我了解了MethodBase.GetCurrentMethod（）的最终结果。我还了解到，不仅可以创建堆栈跟踪，还可以仅创建所需的确切帧。

要在属性中使用它，只需使用.Substring（4）删除“ set_”或“ get_”。

从.NET 4.5开始，您还可以使用[CallerMemberName]

示例：一个属性设置器（用于回答第2部分）：

    protected void SetProperty<T>(T value, [CallerMemberName] string property = null)
    {
        this.propertyValues[property] = value;
        OnPropertyChanged(property);
    }

    public string SomeProperty
    {
        set { SetProperty(value); }
    }

编译器将在调用站点提供匹配的字符串文字，因此基本上没有性能开销。

对于非async方法，可以使用

System.Reflection.MethodBase.GetCurrentMethod().Name;

https://docs.microsoft.com/zh-cn/dotnet/api/system.reflection.methodbase.getcurrentmethod

请记住，对于async方法，它将返回“ MoveNext”。

Lex提供的代码段有点长，所以我指出了重要的部分，因为没有其他人使用完全相同的技术：

string MethodName = new StackFrame(0).GetMethod().Name;

这应该向MethodBase.GetCurrentMethod（）。Name技术返回相同的结果，但是仍然值得指出，因为我可以在其自己的方法中使用上一个方法的索引1来实现一次，并从许多不同的属性中调用它。同样，它只返回一帧，而不是整个堆栈跟踪：

private string GetPropertyName()
{  //.SubString(4) strips the property prefix (get|set) from the name
    return new StackFrame(1).GetMethod().Name.Substring(4);
}

它也是单线的;）

在一个空的控制台程序的Main方法中尝试以下操作：

MethodBase method = MethodBase.GetCurrentMethod();
Console.WriteLine(method.Name);

控制台输出：
Main

当然是。

如果您想操纵一个对象，我实际上使用这样的函数：

public static T CreateWrapper<T>(Exception innerException, params object[] parameterValues) where T : Exception, new()
{
    if (parameterValues == null)
    {
        parameterValues = new object[0];
    }

    Exception exception   = null;
    StringBuilder builder = new StringBuilder();
    MethodBase method     = new StackFrame(2).GetMethod();
    ParameterInfo[] parameters = method.GetParameters();
    builder.AppendFormat(CultureInfo.InvariantCulture, ExceptionFormat, new object[] { method.DeclaringType.Name, method.Name });
    if ((parameters.Length > 0) || (parameterValues.Length > 0))
    {
        builder.Append(GetParameterList(parameters, parameterValues));
    }

    exception = (Exception)Activator.CreateInstance(typeof(T), new object[] { builder.ToString(), innerException });
    return (T)exception;
}

这行：

MethodBase method     = new StackFrame(2).GetMethod();

沿着堆栈框架走，以找到调用方法，然后我们使用反射来获取传递给它的参数信息值，以用于通用错误报告功能。要获取当前方法，只需使用当前堆栈帧（1）即可。

正如其他人对当前方法名称所说的，您还可以使用：

MethodBase.GetCurrentMethod()

我更喜欢遍历堆栈，因为如果从内部看该方法，无论如何它只会创建一个StackCrawlMark。在我看来，直接处理堆栈似乎更清晰

在4.5版之后，您现在可以将[CallerMemberNameAttribute]用作方法参数的一部分，以获取方法名称的字符串-这在某些情况下可能会有所帮助（但实际上在上述示例中）

public void Foo ([CallerMemberName] string methodName = null)

这似乎主要是INotifyPropertyChanged支持的解决方案，以前您在整个事件代码中都乱扔了字符串。

比较获取方法名称的方法- 在LinqPad中使用任意定时构造：

码

void Main()
{
    // from http://blogs.msdn.com/b/webdevelopertips/archive/2009/06/23/tip-83-did-you-know-you-can-get-the-name-of-the-calling-method-from-the-stack-using-reflection.aspx
    // and /programming/2652460/c-sharp-how-to-get-the-name-of-the-current-method-from-code

    var fn = new methods();

    fn.reflection().Dump("reflection");
    fn.stacktrace().Dump("stacktrace");
    fn.inlineconstant().Dump("inlineconstant");
    fn.constant().Dump("constant");
    fn.expr().Dump("expr");
    fn.exprmember().Dump("exprmember");
    fn.callermember().Dump("callermember");

    new Perf {
        { "reflection", n => fn.reflection() },
        { "stacktrace", n => fn.stacktrace() },
        { "inlineconstant", n => fn.inlineconstant() },
        { "constant", n => fn.constant() },
        { "expr", n => fn.expr() },
        { "exprmember", n => fn.exprmember() },
        { "callermember", n => fn.callermember() },
    }.Vs("Method name retrieval");
}

// Define other methods and classes here
class methods {
    public string reflection() {
        return System.Reflection.MethodBase.GetCurrentMethod().Name;
    }
    public string stacktrace() {
        return new StackTrace().GetFrame(0).GetMethod().Name;
    }
    public string inlineconstant() {
        return "inlineconstant";
    }
    const string CONSTANT_NAME = "constant";
    public string constant() {
        return CONSTANT_NAME;
    }
    public string expr() {
        Expression<Func<methods, string>> ex = e => e.expr();
        return ex.ToString();
    }
    public string exprmember() {
        return expressionName<methods,string>(e => e.exprmember);
    }
    protected string expressionName<T,P>(Expression<Func<T,Func<P>>> action) {
        // https://stackoverflow.com/a/9015598/1037948
        return ((((action.Body as UnaryExpression).Operand as MethodCallExpression).Object as ConstantExpression).Value as MethodInfo).Name;
    }
    public string callermember([CallerMemberName]string name = null) {
        return name;
    }
}

结果

反射 反射

堆栈跟踪 stacktrace

内联常数 常量内常量

不变 不变

expr e => e.expr（）

专家 会员

callermember 主

Method name retrieval: (reflection) vs (stacktrace) vs (inlineconstant) vs (constant) vs (expr) vs (exprmember) vs (callermember) 

 154673 ticks elapsed ( 15.4673 ms) - reflection
2588601 ticks elapsed (258.8601 ms) - stacktrace
   1985 ticks elapsed (  0.1985 ms) - inlineconstant
   1385 ticks elapsed (  0.1385 ms) - constant
1366706 ticks elapsed (136.6706 ms) - expr
 775160 ticks elapsed ( 77.516  ms) - exprmember
   2073 ticks elapsed (  0.2073 ms) - callermember


>> winner: constant

请注意，expr和callermember方法并不十分“正确”。在那里您看到重复的相关评论，即反射比stacktrace快15倍。

编辑：MethodBase可能是一种更好的方法来获取您所在的方法（而不是整个调用堆栈）。不过，我仍然会担心内联。

您可以在方法中使用StackTrace：

StackTrace st = new StackTrace(true);

看一下框架：

// The first frame will be the method you want (However, see caution below)
st.GetFrames();

但是，请注意，如果该方法是内联的，则不会进入您认为的方法之内。您可以使用属性来防止内联：

[MethodImpl(MethodImplOptions.NoInlining)]

处理的简单方法是：

System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + System.Reflection.MethodBase.GetCurrentMethod().Name;

如果在using块中包含System.Reflection：

MethodBase.GetCurrentMethod().DeclaringType.FullName + "." + MethodBase.GetCurrentMethod().Name;

这个怎么样：

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

我认为您应该能够通过创建StackTrace来实现。或者，就像@edg和@ LarsMæhlum提到的那样，MethodBase。GetCurrentMethod（）

试试这个...

    /// <summary>
    /// Return the full name of method
    /// </summary>
    /// <param name="obj">Class that calls this method (use Report(this))</param>
    /// <returns></returns>
    public string Report(object obj)
    {
        var reflectedType = new StackTrace().GetFrame(1).GetMethod().ReflectedType;
        if (reflectedType == null) return null;

        var i = reflectedType.FullName;
        var ii = new StackTrace().GetFrame(1).GetMethod().Name;

        return string.Concat(i, ".", ii);
    }

我只是用一个简单的静态类来做到这一点：

using System.Runtime.CompilerServices;
.
.
.
    public static class MyMethodName
        {
            public static string Show([CallerMemberName] string name = "")
            {
                return name;
            }
        }

然后在您的代码中：

private void button1_Click(object sender, EventArgs e)
        {
            textBox1.Text = MyMethodName.Show();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            textBox1.Text = MyMethodName.Show();
        }

new StackTrace().ToString().Split("\r\n",StringSplitOptions.RemoveEmptyEntries)[0].Replace("at ","").Trim()