StringBuilder.Append 与 StringBuilder.AppendFormat

Question

我想知道有关 StringBuilder 的问题，并且有一个问题希望社区能够解释。

让我们忘记代码的可读性，其中哪个更快，为什么？

StringBuilder.Append：

StringBuilder sb = new StringBuilder();
sb.Append(string1);
sb.Append("----");
sb.Append(string2);

StringBuilder.AppendFormat：

StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}----{1}",string1,string2);

Answer 1

如果不知道 string1 和 string2 的大小，就无法确定。

通过调用 AppendFormat< /a>，它将在给定格式字符串和将插入的字符串的长度的情况下预分配缓冲区一次，然后连接所有内容并将其插入缓冲区。 对于非常大的字符串，这比单独调用 更有利Append 这可能会导致缓冲区扩展多次。

但是，对 Append 的三个调用可能会也可能不会触发缓冲区的增长，并且每次调用都会执行该检查。 如果字符串足够小并且不会触发缓冲区扩展，那么它将比调用 AppendFormat 更快，因为它不必解析格式字符串来确定在哪里进行替换。

需要更多数据才能得出明确的答案

应该注意的是，很少讨论使用静态String 类上的Concat 方法 (Jon 使用 AppendWithCapacity 的回答让我想起了这一点）。 他的测试结果表明这是最好的情况（假设您不必利用特定的格式说明符）。 String.Concat 执行相同的操作，因为它将预先确定要连接的字符串的长度并预分配缓冲区（由于通过参数进行循环构造，因此开销稍大）。 它的性能将与 Jon 的 AppendWithCapacity 方法相当。

或者，只是简单的加法运算符，因为无论如何它都会编译为对 String.Concat 的调用，但需要注意的是所有加法都在同一表达式中：

// One call to String.Concat.
string result = a + b + c;

NOT

// Two calls to String.Concat.
string result = a + b;
result = result + c;

---

<对于所有那些放置测试代码的人，

您需要在单独运行中运行测试用例（或者至少在单独测试运行的测量之间执行GC）。 这样做的原因是，如果您确实说运行 1,000,000 次，则会创建一个新的 StringBuilder 在一次测试的循环的每次迭代中，然后运行循环相同次数的下一个测试，创建额外 1,000,000 StringBuilder 实例中，GC 很可能会在第二次测试期间介入并阻碍其计时。

Answer 2

casperOne 是正确的。 一旦达到某个阈值，Append() 方法就会比 AppendFormat() 慢。 以下是每种方法 100,000 次迭代的不同长度和经过的刻度：

长度：1

Append()       - 50900
AppendFormat() - 126826

长度：1000

Append()       - 1241938
AppendFormat() - 1337396

长度：10,000

Append()       - 12482051
AppendFormat() - 12740862

长度：20,000

Append()       - 61029875
AppendFormat() - 60483914

当引入长度接近 20,000 的字符串时，AppendFormat() 函数将稍微优于Append()。

为什么会出现这种情况？ 请参阅 casperOne 的回答。

编辑：

我在发布配置下单独重新运行每个测试并更新了结果。

Answer 3

casperOne 完全准确，它取决于数据。 但是，假设您将其编写为供第三方使用的类库 - 您会使用哪个？

一种选择是两全其美 - 计算出您实际上需要附加多少数据，然后使用 StringBuilder.EnsureCapacity 以确保我们只需要一次缓冲区大小调整。

如果我不太担心，我会使用 Append x3 - 它似乎“更有可能”更快，因为在每次调用时解析字符串格式令牌是显然是在做工作。

请注意，我已要求 BCL 团队提供一种“缓存格式化程序”，我们可以使用格式字符串创建它，然后重复使用。 框架每次使用时都必须解析格式字符串，这太疯狂了。

编辑：好的，为了灵活性，我对约翰的代码进行了一些编辑，并添加了一个“AppendWithCapacity”，它首先计算出必要的容量。 以下是不同长度的结果 - 对于长度 1，我使用了 1,000,000 次迭代； 对于所有其他长度，我使用了 100,000。 （这只是为了获得合理的运行时间。）所有时间均以毫秒为单位。

不幸的是，表格在 SO 中并不能真正工作。 长度为 1, 1000, 10000, 20000

次：

• Append: 162, 475, 7997, 17970
• AppendFormat: 392, 499, 8541, 18993
• AppendWithCapacity: 139, 189, 1558, 3085

所以当它发生时，我从未见过 AppendFormat 击败 Append - 但我确实看到 AppendWithCapacity 以非常大的优势获胜。

这是完整的代码：

using System;
using System.Diagnostics;
using System.Text;

public class StringBuilderTest
{            
    static void Append(string string1, string string2)
    {
        StringBuilder sb = new StringBuilder();
        sb.Append(string1);
        sb.Append("----");
        sb.Append(string2);
    }

    static void AppendWithCapacity(string string1, string string2)
    {
        int capacity = string1.Length + string2.Length + 4;
        StringBuilder sb = new StringBuilder(capacity);
        sb.Append(string1);
        sb.Append("----");
        sb.Append(string2);
    }

    static void AppendFormat(string string1, string string2)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat("{0}----{1}", string1, string2);
    }

    static void Main(string[] args)
    {
        int size = int.Parse(args[0]);
        int iterations = int.Parse(args[1]);
        string method = args[2];

        Action<string,string> action;
        switch (method)
        {
            case "Append": action = Append; break;
            case "AppendWithCapacity": action = AppendWithCapacity; break;
            case "AppendFormat": action = AppendFormat; break;
            default: throw new ArgumentException();
        }

        string string1 = new string('x', size);
        string string2 = new string('y', size);

        // Make sure it's JITted
        action(string1, string2);
        GC.Collect();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i=0; i < iterations; i++)
        {
            action(string1, string2);
        }
        sw.Stop();
        Console.WriteLine("Time: {0}ms", (int) sw.ElapsedMilliseconds);
    }
}

Answer 4

追加在大多数情况下会更快，因为该方法有许多重载，允许编译器调用正确的方法。 由于您使用的是Strings，StringBuilder 可以使用String 重载进行Append。

AppendFormat接受一个String，然后是一个Object[]，这意味着必须解析格式，并且必须将数组中的每个Object ToString'd，然后才能将其添加到 StringBuilder 的 内部数组中。

注意：对于 casperOne 的观点 - 如果没有更多数据，很难给出准确的答案。

Answer 5

StringBuilder 还具有级联追加：Append() 返回 StringBuilder 本身，因此您可以像这样编写代码：

StringBuilder sb = new StringBuilder();
sb.Append(string1)
  .Append("----")
  .Append(string2);

干净，并且生成的代码更少IL 代码（尽管这实际上是一个微观优化）。

Answer 6

当然，要确定每种情况下的概况。

也就是说，我认为一般来说会是前者，因为您没有重复解析格式字符串。

然而，差异会非常小。 无论如何，在大多数情况下您确实应该考虑使用 AppendFormat 。

Answer 7

我认为这是完成最少工作量的调用。 Append 只是连接字符串，而 AppendFormat 则进行字符串替换。 当然，现在你永远无法分辨...

Answer 8

1 应该更快，因为它只是附加字符串，而 2 必须根据格式创建一个字符串，然后附加该字符串。 所以这里还有一个额外的步骤。

Answer 9

在你的情况下更快是 1 但这不是一个公平的比较。 您应该询问 StringBuilder.AppendFormat() 与 StringBuilder.Append(string.Format()) - 由于内部使用 char 数组，第一个更快。

不过，你的第二个选项更具可读性。

Answer 10

在 C# 10/.NET 6+ 中，由于新的 内插字符串处理程序内置于编译器中。 事实上，所有这些都会产生等效的编译代码：

sb.Append(string1);
sb.Append("----");
sb.Append(string2);

sb.AppendFormat("{0}----{1}",string1,string2);

sb.Append($"{string1}----{string2}");

因此，您可以选择最具可读性的代码。