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

Question

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

Answer 1

.NET 性能专家Rico Mariani有一篇关于这个主题的文章。 这并不像人们想象的那么简单。 基本建议是这样的：

如果您的模式如下所示：

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

那是一个 concat，它很活泼， StringBuilder 可能无济于事。

如果您的模式如下所示：

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

那么你可能想要 StringBuilder。

支持这一主张的另一篇文章来自 Eric Lippert，他在其中详细描述了在一行+连接上执行的优化。

Answer 2

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

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

Answer 3

有 6 种类型的字符串连接：

1. 使用加号 ( +<\/code> ) 符号。<\/li>
2. 使用string.Concat()<\/code> 。<\/li>
3. 使用string.Join()<\/code> 。<\/li>
4. 使用string.Format()<\/code> 。<\/li>
5. 使用string.Append()<\/code> 。<\/li>
6. 使用StringBuilder<\/code> 。<\/li><\/ol>

   在实验中，已经证明string.Concat()<\/code>是最好的方法，如果单词少于 1000（大约），如果单词超过 1000，则应该使用StringBuilder<\/code> 。

   有关更多信息，请查看此站点<\/a>。

   string.Join() 与 string.Concat()<\/h3>

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

   <\/blockquote>"

Answer 4

来自Chinh Do - StringBuilder 并不总是更快：

经验法则

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

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

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

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

Answer 5

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

然而，Rico Mariani（.NET 优化大师） 做了一个测验<\/a>，最后他说，在大多数情况下，他推荐String.Format<\/code> 。

Answer 6

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

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

接下来，给定最终字符串的总分配大小，通过就地构建结果字符串可以获得最大的性能提升。 这样做需要（可能有争议的）技术来临时暂停一个新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#调用cpblk IL 指令来进行实际的复制。 如您所见，为了此处代码的简单性和可移植性，我将其替换为 P/Invoke memcpy 。 为了在 x64（ 但可能不是 x86 ）上获得最高性能，您可能需要改用cpblk方法。

Answer 7

从这篇MSDN 文章<\/a>：

创建 StringBuilder 对象会产生一些开销，包括时间和内存。 在具有快速内存的机器上，如果您正在执行大约五个操作，则 StringBuilder 变得有价值。 根据经验，我会说 10 个或更多的字符串操作是任何机器上开销的理由，即使是较慢的机器也是如此。

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

Answer 8

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

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

如何：连接多个字符串（C# 编程指南）

Answer 9

除了其他答案，请记住StringBuilder 可以被告知要分配的初始内存量。

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

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

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

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

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

Answer 10

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

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

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

Answer 11

试试这 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();
    }

Answer 12

最有效的是使用 StringBuilder，如下所示：

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

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

Answer 13

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

Answer 14

另一种解决方案：

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

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

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

它非常非常快。

Answer 15

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

因此，对于超过 2-3 个字符串，请使用DannySmurf 的代码<\/a>。 否则，只需使用 + 运算符。

Answer 16

这实际上取决于您的使用模式。 可以在此处找到 string.Join、string、Concat 和 string.Format 之间的详细基准： String.Format 不适合密集型日志记录<\/a>

（这实际上与我对这个<\/a>问题的回答相同）

Answer 17

我已经测试了此页面中的所有方法，最后我开发了最快且成本更低的解决方案 memory。

注意：在 Framework 4.8 中测试

 [MemoryDiagnoser]
public class StringConcatSimple
{
    private string
        title = "Mr.", firstName = "David", middleName = "Patrick", lastName = "Callan";

    [Benchmark]
    public string FastConcat()
    {
        return FastConcat(
            title, " ", 
            firstName, " ",
            middleName, " ", 
            lastName);
    }

    [Benchmark]
    public string StringBuilder()
    {
        var stringBuilder =
            new StringBuilder();

        return stringBuilder
            .Append(title).Append(' ')
            .Append(firstName).Append(' ')
            .Append(middleName).Append(' ')
            .Append(lastName).ToString();
    }

    [Benchmark]
    public string StringBuilderExact24()
    {
        var stringBuilder =
            new StringBuilder(24);

        return stringBuilder
            .Append(title).Append(' ')
            .Append(firstName).Append(' ')
            .Append(middleName).Append(' ')
            .Append(lastName).ToString();
    }

    [Benchmark]
    public string StringBuilderEstimate100()
    {
        var stringBuilder =
            new StringBuilder(100);

        return stringBuilder
            .Append(title).Append(' ')
            .Append(firstName).Append(' ')
            .Append(middleName).Append(' ')
            .Append(lastName).ToString();
    }

    [Benchmark]
    public string StringPlus()
    {
        return title + ' ' + firstName + ' ' +
            middleName + ' ' + lastName;
    }

    [Benchmark]
    public string StringFormat()
    {
        return string.Format("{0} {1} {2} {3}",
            title, firstName, middleName, lastName);
    }

    [Benchmark]
    public string StringInterpolation()
    {
        return
        $"{title} {firstName} {middleName} {lastName}";
    }

    [Benchmark]
    public string StringJoin()
    {
        return string.Join(" ", title, firstName,
            middleName, lastName);
    }

    [Benchmark]
    public string StringConcat()
    {
        return string.
            Concat(new String[]
            { title, " ", firstName, " ",
                middleName, " ", lastName });
    }
}

是的，它使用不安全

public static unsafe string FastConcat(string str1, string str2, string str3, string str4, string str5, string str6, string str7)
    {
        var capacity = 0;

        var str1Length = 0;
        var str2Length = 0;
        var str3Length = 0;
        var str4Length = 0;
        var str5Length = 0;
        var str6Length = 0;
        var str7Length = 0;

        if (str1 != null)
        {
            str1Length = str1.Length;
            capacity = str1Length;
        }

        if (str2 != null)
        {
            str2Length = str2.Length;
            capacity += str2Length;
        }

        if (str3 != null)
        {
            str3Length = str3.Length;
            capacity += str3Length;
        }

        if (str4 != null)
        {
            str4Length = str4.Length;
            capacity += str4Length;
        }

        if (str5 != null)
        {
            str5Length = str5.Length;
            capacity += str5Length;
        }

        if (str6 != null)
        {
            str6Length = str6.Length;
            capacity += str6Length;
        }

        if (str7 != null)
        {
            str7Length = str7.Length;
            capacity += str7Length;
        }


        string result = new string(' ', capacity);

        fixed (char* dest = result)
        {
            var x = dest;

            if (str1Length > 0)
            {
                fixed (char* src = str1)
                {
                    Unsafe.CopyBlock(x, src, (uint)str1Length * 2); 
                    x += str1Length;
                }
            }

            if (str2Length > 0)
            {
                fixed (char* src = str2)
                {
                    Unsafe.CopyBlock(x, src, (uint)str2Length * 2);
                    x += str2Length;
                }
            }

            if (str3Length > 0)
            {
                fixed (char* src = str3)
                {
                    Unsafe.CopyBlock(x, src, (uint)str3Length * 2);
                    x += str3Length;
                }
            }

            if (str4Length > 0)
            {
                fixed (char* src = str4)
                {
                    Unsafe.CopyBlock(x, src, (uint)str4Length * 2);
                    x += str4Length;
                }
            }

            if (str5Length > 0)
            {
                fixed (char* src = str5)
                {
                    Unsafe.CopyBlock(x, src, (uint)str5Length * 2);
                    x += str5Length;
                }
            }

            if (str6Length > 0)
            {
                fixed (char* src = str6)
                {
                    Unsafe.CopyBlock(x, src, (uint)str6Length * 2);
                    x += str6Length;
                }
            }

            if (str7Length > 0)
            {
                fixed (char* src = str7)
                {
                    Unsafe.CopyBlock(x, src, (uint)str7Length * 2);
                }
            }
        }

        return result;
    }

您可以编辑该方法并使其适应您的情况。 例如你可以让它像

公共 static 不安全字符串 FastConcat（字符串 str1，字符串 str2，字符串 str3 = null，字符串 str4 = null，字符串 str5 = null，字符串 str6 = null，字符串 str7 = null）

Answer 18

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

"