过度使用委托对性能来说是一个坏主意吗？

Question

考虑以下代码：

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

GetDetailedDebugInfo() 可能是一个昂贵的方法，因此我们只想在调试模式下运行时调用它。

现在，更干净的替代方案是编写如下代码：

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

其中 .Log() 定义如下：

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

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

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

（PS：我直接在 StackOverflow 提问文本区域中编写了代码，所以如果有细微的错误并且无法编译，请不要责怪我，你明白了:)

Answer 1

不，应该不会有什么不好的表现。 毕竟，您只会在性能不是最重要的调试模式下调用它。 实际上，您可以删除 lambda 并仅传递方法名称，以消除不必要的中间匿名方法的开销。

请注意，如果您想在调试版本中执行此操作，您可以添加 [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

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

所以我写了一个简单的测试用例：

    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

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

不挂断！ 我已经纠正了！ 当您使用“BeginInvoke”时，委托仅使用线程...因此我的上述评论不适用于您使用它们的方式。

Answer 6

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

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

您还应该对 getMessage 添加 null 检查。

Answer 7

标准答案：

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