StackFrame 的性能如何？

Question

我正在考虑使用 StackFrame stackFrame = new StackFrame(1) 之类的东西来记录执行方法，但我不知道它对性能的影响。堆栈跟踪是在每次方法调用时都构建的，因此性能不应该成为问题，还是只有在被要求时才构建？您是否建议在性能非常重要的应用程序中反对它？如果是这样，这是否意味着我应该在发布时禁用它？

Answer 1

从 MSDN 文档看来，StackFrames 似乎一直在创建：

创建并推送 StackFrame 每个函数调用的调用堆栈 在线程执行期间生成。 堆栈帧总是包括 MethodBase 信息，以及可选的 包括文件名、行号和 列号信息。

你调用的构造函数new StackFrame(1)会这样做：

private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
{
    StackFrameHelper sfh = new StackFrameHelper(fNeedFileInfo, null);
    StackTrace.GetStackFramesInternal(sfh, 0, null);
    int numberOfFrames = sfh.GetNumberOfFrames();
    skipFrames += StackTrace.CalculateFramesToSkip(sfh, numberOfFrames);
    if ((numberOfFrames - skipFrames) > 0)
    {
        this.method = sfh.GetMethodBase(skipFrames);
        this.offset = sfh.GetOffset(skipFrames);
        this.ILOffset = sfh.GetILOffset(skipFrames);
        if (fNeedFileInfo)
        {
            this.strFileName = sfh.GetFilename(skipFrames);
            this.iLineNumber = sfh.GetLineNumber(skipFrames);
            this.iColumnNumber = sfh.GetColumnNumber(skipFrames);
        }
    }
}

GetStackFramesInternal 是一个外部方法。 CalculateFramesToSkip 有一个循环只运行一次，因为您只指定了 1 帧。其他一切看起来都很快。

您是否尝试过衡量创建（例如，100 万个）需要多长时间？

Answer 2

一个快速而幼稚的测试表明，对于性能敏感的代码，是的，你要注意这一点：

不生成 100K 帧：3ms

生成 100K 帧：1805ms

在我的机器上，每个生成的帧大约需要 20 微秒。不是很多，但在大量迭代中会产生可测量的差异。

谈到您以后的问题（“我应该在我的应用程序中禁用 StackFrame 生成吗？”），我建议您分析您的应用程序，像我在这里所做的那样进行性能测试，看看性能差异是否很大任何与您的工作量有关的事情。

using System;
using System.Diagnostics;

namespace ConsoleApplication
{
    class Program
    {
        static bool generateFrame;

        static void Main(string[] args)
        {
            Stopwatch sw;

            // warm up
            for (int i = 0; i < 100000; i++)
            {
                CallA();
            }

            // call 100K times; no stackframes
            sw = Stopwatch.StartNew();
            for (int i = 0; i < 100000; i++)
            {
                CallA();
            }
            sw.Stop();
            Console.WriteLine("Don't generate 100K frames: {0}ms"
                                 , sw.ElapsedMilliseconds);

            // call 100K times; generate stackframes
            generateFrame = true;
            sw = Stopwatch.StartNew();
            for (int i = 0; i < 100000; i++)
            {
                CallA();
            }
            Console.WriteLine("Generate 100K frames: {0}ms"
                           , sw.ElapsedMilliseconds);

            Console.ReadKey();
        }

        private static void CallA()
        {
            CallB();
        }

        private static void CallB()
        {
            CallC();
        }

        private static void CallC()
        {
            if (generateFrame)
            {
                StackFrame stackFrame = new StackFrame(1);
            }
        }
    }
}

Answer 3

编辑：一些背景

---

我们有一个类似的功能，它在 99% 的情况下都被禁用；我们使用的方法如下：

public void DoSomething()
{
    TraceCall(MethodBase.GetCurrentMethod().Name);
    // Do Something
}

public void TraceCall(string methodName)
{
    if (!loggingEnabled) { return; }
    // Log...
}

TraceCall(MethodBase.GetCurrentMethod().Name)

这很简单，但无论是否启用跟踪，我们都会在使用反射查找方法名称时产生性能损失。

我们的选择是，要么在每个方法中要求更多代码（并冒着简单错误或被拒绝的风险），要么在启用日志记录时仅改用StackFrame 来确定调用方法。 p>

选项 A：

public void DoSomething()
{
    if (loggingEnabled)
    {
        TraceCall(MethodBase.GetCurrentMethod().Name);
    }
    // Do Something
}

public void TraceCall(string methodName)
{
    if (!loggingEnabled) { return; }
    // Log...
}

选项 B：

public void DoSomething()
{
    TraceCall();
    // Do Something
}

public void TraceCall()
{
    if (!loggingEnabled) { return; }
    StackFrame stackFrame = new StackFrame(1);
    // Log...
}

我们选择了选项 B。在 99% 的情况下禁用日志记录，它比选项 A 提供了显着的性能改进，并且非常易于实施。 p>

这是对 Michael 代码的修改，以显示这种方法的成本/收益

using System;
using System.Diagnostics;
using System.Reflection;

namespace ConsoleApplication
{
    class Program
    {
        static bool traceCalls;

        static void Main(string[] args)
        {
            Stopwatch sw;

            // warm up
            for (int i = 0; i < 100000; i++)
            {
                TraceCall();
            }

            // call 100K times, tracing *disabled*, passing method name
            sw = Stopwatch.StartNew();
            traceCalls = false;
            for (int i = 0; i < 100000; i++)
            {
                TraceCall(MethodBase.GetCurrentMethod());
            }
            sw.Stop();
            Console.WriteLine("Tracing Disabled, passing Method Name: {0}ms"
                             , sw.ElapsedMilliseconds);

            // call 100K times, tracing *enabled*, passing method name
            sw = Stopwatch.StartNew();
            traceCalls = true;
            for (int i = 0; i < 100000; i++)
            {
                TraceCall(MethodBase.GetCurrentMethod());
            }
            sw.Stop();
            Console.WriteLine("Tracing Enabled, passing Method Name: {0}ms"
                             , sw.ElapsedMilliseconds);

            // call 100K times, tracing *disabled*, determining method name
            sw = Stopwatch.StartNew();
            traceCalls = false;
            for (int i = 0; i < 100000; i++)
            {
                TraceCall();
            }
            Console.WriteLine("Tracing Disabled, looking up Method Name: {0}ms"
                       , sw.ElapsedMilliseconds);

            // call 100K times, tracing *enabled*, determining method name
            sw = Stopwatch.StartNew();
            traceCalls = true;
            for (int i = 0; i < 100000; i++)
            {
                TraceCall();
            }
            Console.WriteLine("Tracing Enabled, looking up Method Name: {0}ms"
                       , sw.ElapsedMilliseconds);

            Console.ReadKey();
        }

        private static void TraceCall()
        {
            if (traceCalls)
            {
                StackFrame stackFrame = new StackFrame(1);
                TraceCall(stackFrame.GetMethod().Name);
            }
        }

        private static void TraceCall(MethodBase method)
        {
            if (traceCalls)
            {
                TraceCall(method.Name);
            }
        }

        private static void TraceCall(string methodName)
        {
            // Write to log
        }
    }
}

结果：

Tracing Disabled, passing Method Name: 294ms
Tracing Enabled,  passing Method Name: 298ms
Tracing Disabled, looking up Method Name: 0ms
Tracing Enabled,  looking up Method Name: 1230ms

Answer 4

我正在考虑使用 StackFrame stackFrame = new StackFrame(1) 之类的东西来记录执行方法

出于兴趣：为什么？如果你只想要当前的方法，那么

string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;

似乎更好。可能性能不高（我没有比较，但 Reflection 表明 GetCurrentMethod() 不仅创建了一个 StackFrame，还做了一些“魔术”），但它的意图更清晰。

Answer 5

我认为 Paul Williams 在完成工作时一针见血。如果您深入研究StackFrameHelper，您会发现fNeedFileInfo 实际上是性能杀手——尤其是在调试模式下。如果性能很重要，请尝试将其设置为 false。无论如何，在发布模式下你不会得到太多有用的信息。

如果您在此处传递 false，则在执行 ToString() 时仍然会获得方法名称，并且不输出任何信息，只是移动堆栈指针，速度非常快。

Answer 6

我知道你的意思，但是这个示例结果是过冲的。即使在关闭日志记录的情况下执行 GetCurrentMethod 也是一种浪费。 它应该是这样的：

if (loggingEnabled) TraceCall(MethodBase.GetCurrentMethod());  

或者，如果您希望 TraceCall 始终执行：

TraceCall(loggingEnabled ? MethodBase.GetCurrentMethod() : null);

Answer 7

我知道这是一篇旧帖子，但万一有人看到它，如果您的目标是 .Net 4.5，还有另一种选择

您可以使用 CallerMemberName 属性来标识调用方法名称。它比反射或 StackFrame 快得多。这是迭代一百万次的快速测试的结果。与反射相比，StackFrame 非常慢，而新属性使两者看起来都像是静止不动。这是在 IDE 中运行的。

反射结果： 00:00:01.4098808

StackFrame 结果 00:00:06.2002501

CallerMemberName 属性结果： 00:00:00.0042708

完成

以下是编译后的exe： 反射结果： 00:00:01.2136738 堆栈帧结果 00:00:03.6343924 CallerMemberName 属性结果： 00:00:00.0000947 完成

        static void Main(string[] args)
    {

        Stopwatch sw = new Stopwatch();

        sw.Stop();

        Console.WriteLine("Reflection Result:");

        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            //Using reflection to get the current method name.
            PassedName(MethodBase.GetCurrentMethod().Name);
        }
        Console.WriteLine(sw.Elapsed);

        Console.WriteLine("StackFrame Result");

        sw.Restart();

        for (int i = 0; i < 1000000; i++)
        {
            UsingStackFrame();
        }

        Console.WriteLine(sw.Elapsed);

        Console.WriteLine("CallerMemberName attribute Result:");

        sw.Restart();
        for (int i = 0; i < 1000000; i++)
        {
            UsingCallerAttribute();
        }

        Console.WriteLine(sw.Elapsed);

        sw.Stop();



        Console.WriteLine("Done");
        Console.Read();
    }


    static void PassedName(string name)
    {

    }

    static void UsingStackFrame()
    {
        string name = new StackFrame(1).GetMethod().Name;
    }


    static void UsingCallerAttribute([CallerMemberName] string memberName = "")
    {

    }