How Much Faster is StringBuilder respect of concat operator + in C# .Net

Question

How Much Faster is StringBuilder respect of concat operator + in C# .Net How it work at low level to work faster than concat?

Answer 1

The Microsoft Developer Network has a great comparison:

Although StringBuilder and String both represent sequences of characters, they are implemented differently. String is an immutable type. That is, each operation that appears to modify a String object actually creates a new string.

For example, the call to the String.Concat method in the following C# example appears to change the value of a string variable named value. In fact, the Concat method returns a value object that has a different value and address from the value object that was passed to the method. Note that the example must be compiled using the /unsafe compiler option. For routines that perform extensive string manipulation (such as apps that modify a string numerous times in a loop), modifying a string repeatedly can exact a significant performance penalty. The alternative is to use StringBuilder, which is a mutable string class. Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. A StringBuilder object maintains a buffer to accommodate expansions to the string. New data is appended to the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, and the new data is then appended to the new buffer.

The recommended usage for a String is:

• When the number of changes that your application will make to a string are quite small. In these instances StringBuilder may offer negligible or no performance improvement over String. (Due to the way the StringBuilder handles its buffer)

• When you are performing a fix number of concatenation operations, particularly with String literals. The Compiler should combine these into one single operation.

• When you have to perform extensive search operations while you are building a String. StringBuilder lacks search methods such as IndexOf or StartsWith. You'll have to convert your StringBuilder object to a String for these operations which may negate the performance.

The recommended usage for StringBuilder:

• When you expect your application to make unknown number of changes to a string at design time (an example would be loops/random number strings).

• When you expect your application to make significant changes to a string.

So the question really shouldn't be, "Which performs better", it should be "Under which circumstance is one more ideal than another?"

Answer 2

Just to contrast the other answer, here is an example that shows concatenation is faster by about 20% on my computer.

public static void ConcatTest()
{
    int NumConcatenations = 10000000;

    const string Postfix = "postfix_";

    /** + Operator concatenation **/
    var sw = Stopwatch.StartNew();
    for (int x = 0; x < NumConcatenations; x++)
    {
        var concatResult = string.Empty;

        for (int i = 0; i < 2; i++)
        {
            concatResult += Postfix;
        }
    }
    var plusOperatorTime = sw.ElapsedMilliseconds;

    Console.WriteLine();

    sw.Reset();

    /** StringBuilder concatenation **/
    sw.Start();
    for (int x = 0; x < NumConcatenations; x++)
    {
        var builder = new StringBuilder(string.Empty);
        for (int i = 0; i < 2; i++)
        {
            builder.Append(Postfix);
        }
    }
    var stringBuilderTime = sw.ElapsedMilliseconds;

    Console.WriteLine(
        "Concatenation with + operator took {0} ms, stringbuilder took {1} ms",
        plusOperatorTime,
        stringBuilderTime);

    Console.ReadLine();
}

Are you concatenating the words of a novel into a book or are you concatenating a million firstname lastname pairs into full name? Your usage determines what is faster. Testing your specific implementation is the only way to know for sure.

Answer 3

WOW ... I'm measuring a 100 fold performance difference. Stringbuilder by far faster. Feel free to tell me what's wrong with my code.

On my system: 200ms for + vs 2 ms for stringbuilder.

       static void Main(string[] args)
    {
        int NumConcatenations = 10000;

        const string Postfix = "postfix_";
        var concatResult = string.Empty;

        /** + Operator concatenation **/
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < NumConcatenations; i++)
        {
            concatResult += Postfix;
        }
        var plusOperatorTime = sw.ElapsedMilliseconds;

        Console.WriteLine();

        sw.Reset();

        /** StringBuilder concatenation **/
        var builder = new StringBuilder(string.Empty);
        sw.Start();
        for (int i = 0; i < NumConcatenations; i++)
        {
            builder.Append(Postfix);
        }
        var stringBuilderTime = sw.ElapsedMilliseconds;

        Debug.Assert(concatResult.Length == builder.ToString().Length);

        Console.WriteLine(
            "Concatenation with + operator took {0} ms, stringbuilder took {1} ms",
            plusOperatorTime,
            stringBuilderTime);

        Console.ReadLine();
    }