String.Join与StringBuilder：哪个更快？

在先前的有关将格式设置double[][]为CSV格式的问题中，建议使用StringBuilder比更快String.Join。这是真的？

简短的答案：这取决于。

长答案：如果您已经有一个字符串数组要连接在一起（使用定界符），这String.Join是最快的方法。

String.Join可以查看所有字符串以找出所需的确切长度，然后再次查找并复制所有数据。这意味着将会有不会涉及额外的复制。该唯一的缺点是，它要经过串两次，这可能手段吹内存缓存更多的时间比必要的。

如果您事先没有将字符串作为数组，则使用可能会更快StringBuilder-但在情况下，可能不是这样。如果使用StringBuilder大量复制的方法，则构建一个数组然后调用String.Join可能会更快。

编辑：这是根据一次调用 String.Join对的多次调用StringBuilder.Append。在最初的问题中，我们有两个不同级别的String.Join调用，因此每个嵌套调用都将创建一个中间字符串。换句话说，它甚至更加复杂且难以猜测。我会惊讶地发现，无论哪种方式，典型数据都能在复杂性方面赢得“胜利”。

编辑：当我在家时，我将写出一个基准测试，该基准测试可能会尽可能地痛苦StringBuilder。基本上，如果您有一个数组，其中每个元素的大小是前一个元素的两倍左右，并且刚好正确，则应该能够为每个追加（元素的而不是定界符的）强制复制一个副本，尽管这需要也要考虑在内）。那时，它几乎和简单的字符串连接一样糟糕-但String.Join不会有问题。

这是我的测试台，int[][]为了简单起见，使用了它。结果优先：

Join: 9420ms (chk: 210710000
OneBuilder: 9021ms (chk: 210710000

（更新double结果：）

Join: 11635ms (chk: 210710000
OneBuilder: 11385ms (chk: 210710000

（更新为2048 * 64 * 150）

Join: 11620ms (chk: 206409600
OneBuilder: 11132ms (chk: 206409600

并启用OptimizeForTesting：

Join: 11180ms (chk: 206409600
OneBuilder: 10784ms (chk: 206409600

这么快，但不是很大；绑定（在控制台上，以发布模式运行等）：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Collect()
        {
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            GC.WaitForPendingFinalizers();
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            GC.WaitForPendingFinalizers();
        }
        static void Main(string[] args)
        {
            const int ROWS = 500, COLS = 20, LOOPS = 2000;
            int[][] data = new int[ROWS][];
            Random rand = new Random(123456);
            for (int row = 0; row < ROWS; row++)
            {
                int[] cells = new int[COLS];
                for (int col = 0; col < COLS; col++)
                {
                    cells[col] = rand.Next();
                }
                data[row] = cells;
            }
            Collect();
            int chksum = 0;
            Stopwatch watch = Stopwatch.StartNew();
            for (int i = 0; i < LOOPS; i++)
            {
                chksum += Join(data).Length;
            }
            watch.Stop();
            Console.WriteLine("Join: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);

            Collect();
            chksum = 0;
            watch = Stopwatch.StartNew();
            for (int i = 0; i < LOOPS; i++)
            {
                chksum += OneBuilder(data).Length;
            }
            watch.Stop();
            Console.WriteLine("OneBuilder: {0}ms (chk: {1}", watch.ElapsedMilliseconds, chksum);

            Console.WriteLine("done");
            Console.ReadLine();
        }
        public static string Join(int[][] array)
        {
            return String.Join(Environment.NewLine,
                    Array.ConvertAll(array,
                      row => String.Join(",",
                        Array.ConvertAll(row, x => x.ToString()))));
        }
        public static string OneBuilder(IEnumerable<int[]> source)
        {
            StringBuilder sb = new StringBuilder();
            bool firstRow = true;
            foreach (var row in source)
            {
                if (firstRow)
                {
                    firstRow = false;
                }
                else
                {
                    sb.AppendLine();
                }
                if (row.Length > 0)
                {
                    sb.Append(row[0]);
                    for (int i = 1; i < row.Length; i++)
                    {
                        sb.Append(',').Append(row[i]);
                    }
                }
            }
            return sb.ToString();
        }
    }
}

我不这么认为。通过Reflector看，执行String.Join来看外观非常优化。它还有一个好处，就是事先知道要创建的字符串的总大小，因此不需要任何重新分配。

我创建了两种测试方法来进行比较：

public static string TestStringJoin(double[][] array)
{
    return String.Join(Environment.NewLine,
        Array.ConvertAll(array,
            row => String.Join(",",
                       Array.ConvertAll(row, x => x.ToString()))));
}

public static string TestStringBuilder(double[][] source)
{
    // based on Marc Gravell's code

    StringBuilder sb = new StringBuilder();
    foreach (var row in source)
    {
        if (row.Length > 0)
        {
            sb.Append(row[0]);
            for (int i = 1; i < row.Length; i++)
            {
                sb.Append(',').Append(row[i]);
            }
        }
    }
    return sb.ToString();
}

我将每个方法运行了50次，并传入了size数组[2048][64]。我这样做是两个阵列。一个用零填充，另一个用随机值填充。我在计算机上获得了以下结果（P4 3.0 GHz，单核，没有HT，从CMD运行Release模式）：

// with zeros:
TestStringJoin    took 00:00:02.2755280
TestStringBuilder took 00:00:02.3536041

// with random values:
TestStringJoin    took 00:00:05.6412147
TestStringBuilder took 00:00:05.8394650

将数组的大小增加到[2048][512]，同时将迭代次数减少到10，可以得到以下结果：

// with zeros:
TestStringJoin    took 00:00:03.7146628
TestStringBuilder took 00:00:03.8886978

// with random values:
TestStringJoin    took 00:00:09.4991765
TestStringBuilder took 00:00:09.3033365

结果是可重复的（几乎；由于不同的随机值而导致的小波动）。显然地String.Join大多数情况下速度要快一些（尽管幅度很小）。

这是我用于测试的代码：

const int Iterations = 50;
const int Rows = 2048;
const int Cols = 64; // 512

static void Main()
{
    OptimizeForTesting(); // set process priority to RealTime

    // test 1: zeros
    double[][] array = new double[Rows][];
    for (int i = 0; i < array.Length; ++i)
        array[i] = new double[Cols];

    CompareMethods(array);

    // test 2: random values
    Random random = new Random();
    double[] template = new double[Cols];
    for (int i = 0; i < template.Length; ++i)
        template[i] = random.NextDouble();

    for (int i = 0; i < array.Length; ++i)
        array[i] = template;

    CompareMethods(array);
}

static void CompareMethods(double[][] array)
{
    Stopwatch stopwatch = Stopwatch.StartNew();
    for (int i = 0; i < Iterations; ++i)
        TestStringJoin(array);
    stopwatch.Stop();
    Console.WriteLine("TestStringJoin    took " + stopwatch.Elapsed);

    stopwatch.Reset(); stopwatch.Start();
    for (int i = 0; i < Iterations; ++i)
        TestStringBuilder(array);
    stopwatch.Stop();
    Console.WriteLine("TestStringBuilder took " + stopwatch.Elapsed);

}

static void OptimizeForTesting()
{
    Thread.CurrentThread.Priority = ThreadPriority.Highest;
    Process currentProcess = Process.GetCurrentProcess();
    currentProcess.PriorityClass = ProcessPriorityClass.RealTime;
    if (Environment.ProcessorCount > 1) {
        // use last core only
        currentProcess.ProcessorAffinity
            = new IntPtr(1 << (Environment.ProcessorCount - 1));
    }
}

除非1％的差异对整个程序的运行时间产生重大影响，否则就好像是微优化。我将编写最易读/易懂的代码，而不必担心1％的性能差异。

阿特伍德（Atwood）大约一个月前有一篇与此相关的文章：

http://www.codinghorror.com/blog/archives/001218.html

是。如果您执行多个联接，则速度会快很多。

当您执行string.join时，运行时必须：

1. 为结果字符串分配内存
2. 将第一个字符串的内容复制到输出字符串的开头
3. 将第二个字符串的内容复制到输出字符串的末尾。

如果执行两次联接，则必须将数据复制两次，依此类推。

StringBuilder会为一个缓冲区分配空间，因此可以在不复制原始字符串的情况下追加数据。由于缓冲区中还有剩余空间，因此可以将附加的字符串直接写入缓冲区。然后，最后只需要复制整个字符串一次。