过度使用代表对性能来说是个坏主意吗？ [复制]

Question

考虑以下代码：

if (IsDebuggingEnabled) { 
   instance.Log(GetDetailedDebugInfo()); 
}

GetDetailedDebugInfo() 可能是一个昂贵的方法，所以我们只想在调试模式下调用它。

现在，更简洁的替代方法是编写如下代码：

instance.Log(() => GetDetailedDebugInfo());

.Log() 的定义如：

public void Log(Func<string> getMessage)
{
    if (IsDebuggingEnabled) 
    {
        LogInternal(getMessage.Invoke());
    }
}

我关心的是性能，初步测试并没有显示第二种情况特别昂贵，但如果负载增加，我不想遇到任何意外。

哦，请不要建议条件编译，因为它不适用于这种情况。

（P.S.：我直接在 StackOverflow Ask a Question textarea 中编写了代码，所以如果有细微的错误并且无法编译，请不要怪我，你明白了 :)

Answer 1

不，它不应该有一个糟糕的表现。毕竟，您只会在性能不在最前沿的调试模式下调用它。实际上，您可以移除 lambda 并传递方法名称，以移除不必要的中间匿名方法的开销。

请注意，如果您想在 Debug 构建中执行此操作，可以在 log 方法中添加 [Conditional("DEBUG")] 属性。

Answer 2

性能存在差异。它的重要性取决于您的其余代码，因此我建议在开始优化之前进行分析。

对于你的第一个例子来说：

if (IsDebuggingEnabled) 
{ 
    instance.Log(GetDetailedDebugInfo()); 
}

如果 IsDebuggingEnabled 是静态只读的，那么检查将被忽略，因为它知道它永远不会改变。这意味着如果 IsDebuggingEnabled 为 false，上述示例对性能的影响为零，因为在 JIT 完成后，代码将消失。

instance.Log(() => GetDetailedDebugInfo());

public void Log(Func<string> getMessage)
{
    if (IsDebuggingEnabled) 
    {
        LogInternal(getMessage.Invoke());
    }
}

每次调用 instance.Log 时都会调用该方法。哪个会慢一些。

但在花时间进行这种微优化之前，您应该分析您的应用程序或运行一些性能测试，以确保这实际上是您应用程序的瓶颈。

Answer 3

我希望有一些关于这种情况下性能的文档，但似乎我得到的只是关于如何改进我的代码的建议......似乎没有人阅读我的 P.S. - 你没有积分。

于是我写了一个简单的测试用例：

    public static bool IsDebuggingEnabled { get; set; }


    static void Main(string[] args)
    {
        for (int j = 0; j <= 10; j++)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i <= 15000; i++)
            {
                Log(GetDebugMessage);
                if (i % 1000 == 0) IsDebuggingEnabled = !IsDebuggingEnabled;
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }

        Console.ReadLine();
        for (int j = 0; j <= 10; j++)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i <= 15000; i++)
            {
                if (IsDebuggingEnabled) GetDebugMessage();
                if (i % 1000 == 0) IsDebuggingEnabled = !IsDebuggingEnabled;
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }
        Console.ReadLine();
    }

    public static string GetDebugMessage()
    {
        StringBuilder sb = new StringBuilder(100);
        Random rnd = new Random();
        for (int i = 0; i < 100; i++)
        {
            sb.Append(rnd.Next(100, 150));
        }
        return sb.ToString();
    }

    public static void Log(Func<string> getMessage)
    {
        if (IsDebuggingEnabled)
        {
            getMessage();
        }
    }

两个版本的时间似乎完全相同。 我在第一种情况下得到 145 毫秒，在第二种情况下得到 145 毫秒

看起来我回答了我自己的问题。

Answer 4

您也可以这样做：

// no need for a lambda
instance.Log(GetDetailedDebugInfo)

// Using these instance methods on the logger
public void Log(Func<string> detailsProvider)
{
    if (!DebuggingEnabled)
        return;

    this.LogImpl(detailsProvider());
}

public void Log(string message)
{
    if (!DebuggingEnabled)
        return;

    this.LogImpl(message);
}

protected virtual void LogImpl(string message)
{
    ....
}

Answer 5

标准答案：

• 如果你必须这样做，你就必须这样做。
• 循环 10^9 次，看一下秒表，它会告诉您需要多少纳秒。
• 如果您的程序很大，您可能在其他地方遇到更大的问题。

Answer 6

直接调用 getMessage 委托而不是对其调用 Invoke。

if(IsDebuggingEnabled)
{
  LogInternal(getMessage());
}

您还应该在 getMessage 上添加空检查。

Answer 7

我相信委托会创建一个新线程，因此您对它提高性能的看法可能是正确的。 为什么不像 Dav 建议的那样设置测试运行，并密切关注您的应用产生的线程数，您可以使用 Process Explorer。

等一下！我已经纠正了！代表仅在您使用“BeginInvoke”时使用线程......所以我上面的 cmets 不适用于您使用它们的方式。