连接字符串的最有效方法？

Question

连接字符串最有效的方法是什么？

Answer 1

最高效的是使用StringBuilder，像这样：

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy：如果你有一些小东西，String.Concat 很好。但是，如果您要连接数兆字节的数据，您的程序可能会崩溃。

Answer 2

StringBuilder.Append() 方法比使用+ 运算符要好得多。但我发现，当执行 1000 次或更少的连接时，String.Join() 甚至比 StringBuilder 更有效率。

StringBuilder sb = new StringBuilder();
sb.Append(someString);

String.Join 的唯一问题是您必须使用公共分隔符连接字符串。

编辑：正如@ryanversaw所指出的，您可以将分隔符设为string.Empty。

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Answer 3

对于只有两个字符串，你肯定不想使用 StringBuilder。有一个阈值，超过该阈值 StringBuilder 开销小于分配多个字符串的开销。

因此，对于超过 2-3 个字符串，请使用 DannySmurf's code。否则，只需使用 + 运算符。

Answer 4

来自Chinh Do - StringBuilder is not always faster：

经验法则

• 当串联三个或更少的动态字符串值时，使用传统的字符串串联。

• 当连接三个以上动态字符串值时，使用StringBuilder。

• 从多个字符串文字构建大字符串时，请使用 @ 字符串文字或内联 + 运算符。

大多数情况下 StringBuilder 是您最好的选择，但如该帖子所示，您至少应该考虑每种情况。

Answer 5

这取决于代码。 StringBuilder 通常更有效，但如果您只是连接几个字符串并在一行中完成所有操作，代码优化可能会为您处理它。考虑代码的外观也很重要：对于较大的集合 StringBuilder 将使其更易于阅读，对于较小的集合 StringBuilder 只会增加不必要的混乱。

Answer 6

如果您在循环中操作，StringBuilder 可能是要走的路；它为您节省了定期创建新字符串的开销。不过，在只运行一次的代码中，String.Concat 可能没问题。

不过，Rico Mariani（.NET 优化大师）made up a quiz 最后表示，在大多数情况下，他推荐String.Format。

Answer 7

Rico Mariani，.NET 性能专家，在这个主题上有 an article。这并不像人们想象的那么简单。基本建议是这样的：

如果你的模式看起来像：

x = f1(...) + f2(...) + f3(...) + f4(...)

这是一个 concat，它是 zippy，StringBuilder 可能无济于事。

如果你的模式看起来像：

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

那么您可能需要 StringBuilder。

Yet another article to support this claim 来自 Eric Lippert，他在其中详细描述了在一行 + 连接上执行的优化。

Answer 8

来自MSDN article：

有一些相关的开销 创建一个 StringBuilder 对象，两者 在时间和记忆中。在一台机器上 内存快，StringBuilder 变成 如果你正在做大约五个，这是值得的 操作。根据经验，我 会说 10 个或更多的字符串操作 是开销的理由 任何机器，甚至是速度较慢的机器。

因此，如果您信任 MSDN，如果您必须执行 10 个以上的字符串操作/连接，请使用 StringBuilder - 否则使用“+”的简单字符串连接很好。

Answer 9

这真的取决于您的使用模式。 string.Join、string、Concat 和 string.Format 之间的详细基准可以在这里找到：String.Format Isn't Suitable for Intensive Logging

（这实际上是我给this问题的答案）

Answer 10

字符串连接有6种类型：

1. 使用加号 (+)。
2. 使用string.Concat()。
3. 使用string.Join()。
4. 使用string.Format()。
5. 使用string.Append()。
6. 使用StringBuilder。

实验证明string.Concat()是接近1000（近似）字数的最佳方法，如果字数超过1000，则应使用StringBuilder。

有关更多信息，请查看此site。

string.Join() 与 string.Concat()

这里的 string.Concat 方法等价于使用空分隔符调用 string.Join 方法。附加一个空字符串很快，但不这样做会更快，所以 string.Concat 方法在这里会更好。

Answer 11

同样重要的是要指出，如果要连接 string literals，则应使用 + 运算符。

当您使用 + 运算符连接字符串文字或字符串常量时，编译器会创建一个字符串。不会发生运行时连接。

How to: Concatenate Multiple Strings (C# Programming Guide)

Answer 12

System.String 是不可变的。当我们修改字符串变量的值时，会为新值分配新内存，并释放先前的内存分配。 System.StringBuilder 旨在具有可变字符串的概念，其中可以执行各种操作而无需为修改后的字符串分配单独的内存位置。

Answer 13

除了其他答案，请记住StringBuilder can be told an initial amount of memory to allocate。

capacity 参数定义了当前实例分配的内存中可以存储的最大字符数。它的值分配给Capacity 属性。如果当前实例中要存储的字符数超过此 容量 值，则 StringBuilder 对象会分配额外的内存来存储它们。

如果容量为零，则使用特定于实现的默认容量。

重复附加到尚未预分配的 StringBuilder 可能会导致大量不必要的分配，就像重复连接常规字符串一样。

如果您知道最终字符串的长度，可以简单地计算它，或者可以对常见情况做出有根据的猜测（分配太多不一定是坏事），您应该将此信息提供给构造函数或Capacity 属性。 特别是在运行性能测试以比较 StringBuilder 与其他方法（如 String.Concat）时，它们在内部做同样的事情。您在网上看到的任何在其比较中不包括 StringBuilder 预分配的测试都是错误的。

如果您无法对大小做出任何猜测，那么您可能正在编写一个实用函数，它应该有自己的可选参数来控制预分配。

Answer 14

试试这2段代码，你会找到解决办法的。

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

对比

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

你会发现第一个代码会很快结束，而且内存会很大。

第二个代码可能内存还可以，但需要更长的时间……更长的时间。 因此，如果您有一个适用于大量用户的应用程序并且您需要速度，请使用第一个。如果您有一个短期的单用户应用程序，也许您可​​以同时使用这两种应用程序，否则对于开发人员来说，第二个应用程序会更“自然”。

干杯。

Answer 15

以下可能是连接多个字符串的另一种替代解决方案。

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

string interpolation

Answer 16

这是我十多年来为我的大型 NLP 应用开发的最快的方法。我有 IEnumerable<T> 和其他输入类型的变体，有和没有不同类型的分隔符（Char、String），但这里我展示了 连接数组中的所有字符串的简单情况 变成一个字符串，没有分隔符。此处的最新版本是在 C# 7 和 .NET 4.7 上开发和单元测试的。

提高性能有两个关键；首先是预先计算所需的确切总大小。当输入是此处所示的数组时，此步骤很简单。为了处理IEnumerable<T>，值得首先将字符串收集到一个临时数组中以计算总数（该数组需要避免每个元素多次调用ToString()，因为从技术上讲，考虑到副作用的可能性，做所以可能会改变“字符串连接”操作的预期语义）。

接下来，考虑到最终字符串的总分配大小，就地构建结果字符串可以获得最大的性能提升。这样做需要（可能有争议的）技术来暂时暂停新的String 的不变性，该新String 最初分配的都是零。但是，除了任何此类争议......

...请注意，这是此页面上唯一的批量连接解决方​​案，它完全避免了String 构造函数的额外一轮分配和复制。

完整代码：

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

我应该提到，这段代码与我自己使用的代码略有修改。在原文中，我从 C# 中的call the cpblk IL instruction 进行实际的复制。如您所见，为了此处代码的简单性和可移植性，我将其替换为 P/Invoke memcpy。为了在 x64 (but maybe not x86) 上获得最高性能，您可能需要改用 cpblk 方法。

Answer 17

另一种解决方案：

在循环中，使用 List 而不是字符串。

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

非常非常快。