5.5. StringBuilder

The primary drawback of strings is that memory must be allocated each time the contents of a string variable are changed. Suppose we create a loop that iterates 100 times and concatenates one character to a string during each iteration. We could end up with a hundred strings in memory, each differing from its preceding one by a single character.

The StringBuilder class addresses this problem by allocating a work area (buffer) where its methods can be applied to the string. These methods include ways to append, insert, delete, remove, and replace characters. After the operations are complete, the ToString method is called to convert the buffer to a string that can be assigned to a string variable. Listing 5-1 introduces some of the StringBuilder methods in an example that creates a comma delimited list.

Listing 5-1. Introduction to StringBuilder

using System;

using System.Text;

public class MyApp

{

   static void Main()

   {

      // Create comma delimited string with quotes around names

      string namesF = "Jan Donna Kim ";

      string namesM = "Rob James";

      StringBuilder sbCSV = new StringBuilder();

      sbCSV.Append(namesF).Append(namesM);

      sbCSV.Replace(" ","','");

      // Insert quote at beginning and end of string

      sbCSV.Insert(0,"'").Append("'");

      string csv = sbCSV.ToString();

      // csv = 'Jan','Donna','Kim','Rob','James'

   }

}

All operations occur in a single buffer and require no memory allocation until the final assignment to csv. Let's take a formal look at the class and its members.

StringBuilder Class Overview

Constructors for the StringBuilder class accept an initial string value as well as integer values that specify the initial space allocated to the buffer (in characters) and the maximum space allowed.

// Stringbuilder(initial value)

StringBuilder sb1 = new StringBuilder("abc");

// StringBuilder(initial value, initial capacity)

StringBuilder sb2 = new StringBuilder("abc", 16);

// StringBuiler(Initial Capacity, maximum capacity)

StringBuilder sb3 = new StringBuilder(32,128);

The idea behind StringBuilder is to use it as a buffer in which string operations are performed. Here is a sample of how its Append, Insert, Replace, and Remove methods work:

int i = 4;

char[] ch = {'w','h','i','t','e'};

string myColor = " orange";

StringBuilder sb = new StringBuilder("red blue green");

sb.Insert(0, ch);              // whitered blue green

sb.Insert(5," ");              // white red blue green

sb.Insert(0,i);                // 4white red blue green

sb.Remove(1,5);                // 4 red blue green

sb.Append(myColor);            // 4 red blue green orange

sb.Replace("blue","violet");   // 4 red violet green orange

string colors = sb.ToString();

StringBuilder Versus String Concatenation

Listing 5-2 tests the performance of StringBuilder versus the concatenation operator. The first part of this program uses the + operator to concatenate the letter a to a string in each of a loop's 50,000 iterations. The second half does the same, but uses the StringBuilder.Append method. The Environment.TickCount provides the beginning and ending time in milliseconds.

Listing 5-2. Comparison of StringBuilder and Regular Concatenation

using System;

using System.Text;

public class MyApp

{

   static void Main()

   {

      Console.WriteLine("String routine");

      string a = "a";

      string str = string.Empty;

      int istart, istop;

      istart = Environment.TickCount;

      Console.WriteLine("Start: "+istart);

      // Use regular C# concatenation operator

      for(int i=0; i<50000; i++)

      {

         str += a;

      }

      istop = Environment.TickCount;

      Console.WriteLine("Stop: "+istop);

      Console.WriteLine("Difference: " + (istop-istart));

      // Perform concatenation with StringBuilder

      Console.WriteLine("StringBuilder routine");

      StringBuilder builder = new StringBuilder();

      istart = Environment.TickCount;

      Console.WriteLine("Start: "+istart);

      for(int i=0; i<50000; i++)

      {

         builder.Append(a);

      }

      istop = Environment.TickCount;

      str = builder.ToString();

      Console.WriteLine("Stop: "+Environment.TickCount);

      Console.WriteLine("Difference: "+ (istop-istart));

   }

}

Executing this program results in the following output:

String routine

Start: 1422091687

Stop: 1422100046

Difference: 9359

StringBuilder routine

Start: 1422100046

Stop: 1422100062

Difference: 16

The results clearly indicate the improved performance StringBuilder provides: The standard concatenation requires 9,359 milliseconds versus 16 milliseconds for StringBuilder. When tested with loops of 1,000 iterations, StringBuilder shows no significant advantage. Unless your application involves extensive text manipulation, the standard concatenation operator should be used.