Concatenation Performance

July 9^th, 2002

In most .NET performance articles you will read the tip to use the StringBuilder class for string concatenation. In this article you will learn whether and when this statement is valid.

Introduction

Take any article dealing with performance issues in .NET applications and in most cases you will read that it is advisable to use the StringBuilder class (namespace: System.Text) for string concatenations. However, regardless of all advantages the StringBuilder class has, from the programmer's perspective it is less comfortable than operator (+) concatenation (be it only that you need to create a new instance of that class). In that context, the question arises whether or not it is always necessary to use the StringBuilder. The intuition is that for only few concatenation statements it shouldn't matter. I decided to find out if the intuition is right and performed a series of tests to that end.

Methodology

In the performance test two contatenation methods were analysed: operator (+) concatenation and StringBuilder concatenation. In order to simulate different real-world scenarios, for every concatenation method

• a different number of concatenations
• of different-length strings

Below is the source code of the console application used for the test. By changing the first four variables, you can adapt the string lengts and iteration steps to your needs.

Code for the performance tests

using System;
using System.Text;
using System.IO;
namespace PerformanceTests
{
  class Concatenation
  {
    private static int IterationsMaxPower = 12;
    private static int IterationsPowerBase = 2;
    private static int StringLenMaxPower = 3;
    private static int StringLenPowerBase = 10;
    [STAThread]
    static void Main(string[] args)
    {
      CommaSeparated();
    }
    private static void CommaSeparated()
    {
      int IterationsCount;
      string StrToConcatenate = String.Empty;
      string Buffer;
      DateTime start;
      DateTime end;
      TimeSpan DurationPlus = TimeSpan.Zero;
      TimeSpan DurationStringBuilder = TimeSpan.Zero;
      Console.WriteLine("Number of Iterations,String Length,Duration Plus Method [ticks],Duration StringBuilder Method [ticks]");
      for (int IterationsPower = 0; IterationsPower <= IterationsMaxPower; IterationsPower++)
      {
        IterationsCount = (int) Math.Pow((double) IterationsPowerBase, (double) IterationsPower);
        for (int StringLenPower = 0; StringLenPower <= StringLenMaxPower; StringLenPower++)
        {
          Buffer = String.Empty;
          StrToConcatenate = new String('#', (int) Math.Pow((double) StringLenPowerBase, (double) StringLenPower));
          // + Concatenation
          // Timer on
          start = DateTime.Now;
          for (int Iteration = 1; Iteration <= IterationsCount; Iteration++)
          {
            Buffer += StrToConcatenate;
          }
          // Timer off
          end = DateTime.Now;
          DurationPlus = end - start;
          Buffer = String.Empty;
          // StringBuilder Concatenation
          // Timer on
          start = DateTime.Now;
          StringBuilder sb = new StringBuilder(IterationsCount);
          for (int Iteration = 1; Iteration <= IterationsCount; Iteration++)
          {
            sb.Append(StrToConcatenate);
          }
          Buffer = sb.ToString();
          // Timer off
          end = DateTime.Now;
          DurationStringBuilder = end - start;
          Console.WriteLine("{0},{1},{2},{3}", IterationsCount, StrToConcatenate.Length, DurationPlus.Ticks, DurationStringBuilder.Ticks);
        }
      }
    }
  }
}

• Download the console application as executable.
• Download the batch file for multiple tests.

Results

The table below summarizes the results of the performance tests. Each figure is an average of the five tests (see Methodology).

Note: A tick is equal to 100 nanoseconds. Anotherwords, one second equals 10 million ticks. E.g., concatenating a 100-character string 2048 times took 4.7 seconds with the operator (+) methods whereas it took 0.002 second with the StringBuilder method.

Findings

1. Up to four iterations the concatenation method is irrelevant. This applies for 1-character strings as well for 1000-character strings.
2. For short strings (1 to 10 characters) and up to 128 iterations the concatenation method is irrelevant.
3. The longer the string to concatenate, the greater the relative advantage of the StringBuilder method over the operator (+) method. With growing number of iterations for the same string length, the relative advantage of the StringBuilder method grows too. E.g., concatenating a 1000-character string 128 times with the operator (+) method takes 44 times more time than with the StringBuilder method; concatenating the same string 4096 times with the operator (+) method is 1118 times longer than with the StringBuilder method. At the same time, the StringBuilder method is "only" 43 times faster than the operator (+) method when concatenating 1-character strings 4096 times.

If you have any comments, please feel free to air them (Feedback button).