UPDATE
Following Mr Cheese's answer, it seems that the
public static string Join<T>(string separator, IEnumerable<T> values)
overload of string.Join gets its advantage from the use of the StringBuilderCache class.
Does anybody have any feedback on the correctness or reason of this statement?
Could I write my own,
public static string Join<T>(
string separator,
string prefix,
string suffix,
IEnumerable<T> values)
function that uses the StringBuilderCache class?
After submitting my answer to this question I got drawn into some analysis of which would be the best performing answer.
I wrote this code, in a console Program class to test my ideas.
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();
}
}
running the code, in release configuration, built with optimizations, from the command line I get output like this.
...
Build time = 1555ms
JoinFormat time = 1715ms
JoinConcat time = 1452ms
The only suprise here (to me) is that the Join-Format combination is the slowest. After considering this answer, this makes a little more sense, the output of the string.Join is being processed by the outer StringBuilder in string.Format, there is an inherent delay with this approach.
After musing, I don't clearly understand how string.Join can be faster. I've read about its use of FastAllocateString() but I don't understand how the buffer can be accurately pre-allocated without calling .ToString() on every member of sequence. Why is the Join-Concat combination faster?
Once I understand that, would it be possible to write my own unsafe string Join function, that takes the extra prefix and suffix parameters and out performs the "safe" alternatives.
I've had several attempts and whilst they work, they are not faster.
