更新
按照奶酪先生的回答，似乎
public static string Join<T>(string separator, IEnumerable<T> values)
重载string.Join从类的使用中获得了它的优势StringBuilderCache。
有人对本声明的正确性或理由有任何反馈吗？
可以自己写吗
public static string Join<T>(
string separator,
string prefix,
string suffix,
IEnumerable<T> values)
使用StringBuilderCache类的函数？
在提交我对这个问题的答案后，我开始分析哪些是表现最好的答案。
我在控制台类中编写了这段代码Program来测试我的想法。
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
class Program
{
static void Main()
{
const string delimiter = ",";
const string prefix = "[";
const string suffix = "]";
const int iterations = 1000000;
var sequence = Enumerable.Range(1, 10).ToList();
Func<IEnumerable<int>, string, string, string, string>[] joiners =
{
Build,
JoinFormat,
JoinConcat
};
// Warmup
foreach (var j in joiners)
{
Measure(j, sequence, delimiter, prefix, suffix, 5);
}
// Check
foreach (var j in joiners)
{
Console.WriteLine(
"{0} output:\"{1}\"",
j.Method.Name,
j(sequence, delimiter, prefix, suffix));
}
foreach (var result in joiners.Select(j => new
{
j.Method.Name,
Ms = Measure(
j,
sequence,
delimiter,
prefix,
suffix,
iterations)
}))
{
Console.WriteLine("{0} time = {1}ms", result.Name, result.Ms);
}
Console.ReadKey();
}
private static long Measure<T>(
Func<IEnumerable<T>, string, string, string, string> func,
ICollection<T> source,
string delimiter,
string prefix,
string suffix,
int iterations)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
for (var i = 0; i < iterations; i++)
{
func(source, delimiter, prefix, suffix);
}
stopwatch.Stop();
return stopwatch.ElapsedMilliseconds;
}
private static string JoinFormat<T>(
IEnumerable<T> source,
string delimiter,
string prefix,
string suffix)
{
return string.Format(
"{0}{1}{2}",
prefix,
string.Join(delimiter, source),
suffix);
}
private static string JoinConcat<T>(
IEnumerable<T> source,
string delimiter,
string prefix,
string suffix)
{
return string.Concat(
prefix,
string.Join(delimiter, source),
suffix);
}
private static string Build<T>(
IEnumerable<T> source,
string delimiter,
string prefix,
string suffix)
{
var builder = new StringBuilder();
builder = builder.Append(prefix);
using (var e = source.GetEnumerator())
{
if (e.MoveNext())
{
builder.Append(e.Current);
}
while (e.MoveNext())
{
builder.Append(delimiter);
builder.Append(e.Current);
}
}
builder.Append(suffix);
return builder.ToString();
}
}
从命令行运行代码，在发布配置中，使用优化构建，我得到这样的输出。
...
构建时间 = 1555ms
JoinFormat 时间 = 1715ms
JoinConcat 时间 = 1452ms
这里（对我来说）唯一的惊喜是 Join-Format 组合是最慢的。在考虑了这个答案之后，这更有意义了，输出string.Join正在由外部处理StringBuilder，string.Format这种方法存在固有的延迟。
沉思之后，我并不清楚如何string.Join才能更快。我已经阅读了它的用法，FastAllocateString()但我不明白如何在不调用.ToString()每个成员的情况下准确地预分配缓冲区sequence。为什么 Join-Concat 组合更快？
一旦我理解了这一点，是否有可能编写我自己的unsafe string Join函数，它需要额外的prefix和suffix参数，并执行“安全”的替代方案。
我已经进行了几次尝试，虽然它们起作用了，但它们并没有更快。