在previous question 中关于将double[][] 格式化为CSV 格式，it was suggested 使用StringBuilder 会比String.Join 更快。这是真的吗？
【问题讨论】：
标签： .net performance string stringbuilder
简短回答：视情况而定。
长答案：如果您已经有要连接在一起的字符串数组（带有分隔符），String.Join 是最快的方法。
String.Join 可以查看所有字符串以计算出所需的确切长度，然后再次复制所有数据。这意味着将没有涉及额外的复制。 唯一的缺点是它必须遍历字符串两次，这意味着可能会比必要的次数更多地破坏内存缓存。
如果您没有事先将字符串作为数组，则可能使用StringBuilder 会更快-但在某些情况下它不是。如果使用StringBuilder 意味着要进行大量复制，那么构建一个数组然后调用String.Join 可能会更快。
编辑：这是对String.Join 的一次调用与对StringBuilder.Append 的一堆调用。在最初的问题中，我们有两个不同级别的 String.Join 调用，因此每个嵌套调用都会创建一个中间字符串。换句话说，它更复杂，更难猜测。我会惊讶地看到任何一种方式在典型数据上都显着（在复杂性方面）“获胜”。
编辑：当我在家时，我会写一个对StringBuilder 来说尽可能痛苦的基准。基本上，如果你有一个数组，其中每个元素的大小大约是前一个元素的两倍，并且你得到它恰到好处，你应该能够为每个追加（元素，而不是分隔符，尽管需要也要考虑在内）。在这一点上，它几乎和简单的字符串连接一样糟糕 - 但String.Join 不会有任何问题。
【讨论】：
StringBuilder，然后调用一次Append？是的，我希望string.Join 在那里获胜。
string.Join 的当前 (.NET 4.5) 实现使用 StringBuilder。
这是我的测试台，为简单起见使用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
速度如此之快，但规模不大； rig（在控制台运行，在发布模式等）：
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();
}
}
}
【讨论】：
OptimizeForTesting() 方法，您的结果也会有所不同吗？
我不这么认为。通过 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 次，传入大小为 [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% 的性能差异。
【讨论】：
是的。如果您执行的连接超过几个，它会快很多。
当您执行 string.join 时，运行时必须：
如果你做两个连接，它必须复制数据两次，依此类推。
StringBuilder 为一个缓冲区分配空间，因此无需复制原始字符串即可追加数据。由于缓冲区中有剩余空间，附加的字符串可以直接写入缓冲区。 然后它只需要在最后复制整个字符串一次。
【讨论】：