Fairly Realistic

Have you ever spent time thinking about how string concatenation works in .NET? Probably not (and I can’t blame you for this) but if you were wondering then please continue.

If you remember way back to your first programming class, you probably learned about how strings work and how they’re not really a primitive type (even though they masquerade as one). Strings are really just collections of characters. Let’s skip Computer Science One for right now and look more closely at how .NET handles string concatenation. If this is the first time you’ve heard that a string is not a primitive type (it’s just a collection of characters, blah, blah blah), then by all means please search on Google for more lengthy explanations.

There are three common ways to concatenate a string in C#:

1. The overloaded + (plus) operator
2. String formatters
3. StringBuilder

I wanted to see which one was really more efficient within the .NET Framework so I created three versions of a console application that built a simple string.

The first version was using the + (plus) operator. Here is the C# code:
<br /> string bar;<br /> string name = “Nicole”;<br /> string thing = “glasses”;</p> <p>bar = “Hello ” + name + “! Have you seen my ” + thing + “?”;<br />

This is the generated IL code for the + (plus) operator concatenation:
<br /> // Code Size: 59 byte(s)<br /> .method private hidebysig static void Main(string[] args) cil managed<br /> {<br /> .custom instance void [mscorlib]System.STAThreadAttribute::.ctor()<br /> .entrypoint<br /> .maxstack 3<br /> .locals init (<br /> string text1,<br /> string text2,<br /> string text3,<br /> string[] textArray1)<br /> L_0000: ldstr “Nicole”<br /> L_0005: stloc.1<br /> L_0006: ldstr “glasses”<br /> L_000b: stloc.2<br /> L_000c: ldc.i4.5<br /> L_000d: newarr string<br /> L_0012: stloc.3<br /> L_0013: ldloc.3<br /> L_0014: ldc.i4.0<br /> L_0015: ldstr “Hello ”<br /> L_001a: stelem.ref<br /> L_001b: ldloc.3<br /> L_001c: ldc.i4.1<br /> L_001d: ldloc.1<br /> L_001e: stelem.ref<br /> L_001f: ldloc.3<br /> L_0020: ldc.i4.2<br /> L_0021: ldstr “! Have you seen my ”<br /> L_0026: stelem.ref<br /> L_0027: ldloc.3<br /> L_0028: ldc.i4.3<br /> L_0029: ldloc.2<br /> L_002a: stelem.ref<br /> L_002b: ldloc.3<br /> L_002c: ldc.i4.4<br /> L_002d: ldstr “?”<br /> L_0032: stelem.ref<br /> L_0033: ldloc.3<br /> L_0034: call string string::Concat(string[])<br /> L_0039: stloc.0<br /> L_003a: ret<br /> }<br />

The second version was using a string formatter. Here is the C# code:
<br /> string foo;<br /> string name = “Nicole”;<br /> string thing = “glasses”;</p> <p>foo = string.Format(”Hello {0}! Have you seen my {1}?”, name, thing);<br />

This is the generated IL code for the string formatter concatenation:
<br /> // Code Size: 26 byte(s)<br /> .method private hidebysig static void Main(string[] args) cil managed<br /> {<br /> .custom instance void [mscorlib]System.STAThreadAttribute::.ctor()<br /> .entrypoint<br /> .maxstack 3<br /> .locals init (<br /> string text1,<br /> string text2,<br /> string text3)<br /> L_0000: ldstr “Nicole”<br /> L_0005: stloc.1<br /> L_0006: ldstr “glasses”<br /> L_000b: stloc.2<br /> L_000c: ldstr “Hello {0}! Have you seen my {1}?”<br /> L_0011: ldloc.1<br /> L_0012: ldloc.2<br /> L_0013: call string string::Format(string, object, object)<br /> L_0018: stloc.0<br /> L_0019: ret<br /> }<br />

The third version was using a StringBuilder. Here is the C# code:
<br /> StringBuilder foo = new StringBuilder();</p> <p>foo.Append(”Hello “);<br /> foo.Append(name);<br /> foo.Append(”! Have you seen my “);<br /> foo.Append(thing);<br /> foo.Append(”?”);<br />

This is the generated IL code for the StringBuilder concatenation:
<br /> // Code Size: 71 byte(s)<br /> .method private hidebysig static void Main(string[] args) cil managed<br /> {<br /> .custom instance void [mscorlib]System.STAThreadAttribute::.ctor()<br /> .entrypoint<br /> .maxstack 2<br /> .locals init (<br /> string text1,<br /> string text2,<br /> [mscorlib]System.Text.StringBuilder builder1)<br /> L_0000: ldstr “Nicole”<br /> L_0005: stloc.0<br /> L_0006: ldstr “glasses”<br /> L_000b: stloc.1<br /> L_000c: newobj instance void [mscorlib]System.Text.StringBuilder::.ctor()<br /> L_0011: stloc.2<br /> L_0012: ldloc.2<br /> L_0013: ldstr “Hello ”<br /> L_0018: callvirt instance [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)<br /> L_001d: pop<br /> L_001e: ldloc.2<br /> L_001f: ldloc.0<br /> L_0020: callvirt instance [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)<br /> L_0025: pop<br /> L_0026: ldloc.2<br /> L_0027: ldstr “! Have you seen my ”<br /> L_002c: callvirt instance [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)<br /> L_0031: pop<br /> L_0032: ldloc.2<br /> L_0033: ldloc.1<br /> L_0034: callvirt instance [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)<br /> L_0039: pop<br /> L_003a: ldloc.2<br /> L_003b: ldstr “?”<br /> L_0040: callvirt instance [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)<br /> L_0045: pop<br /> L_0046: ret<br /> }<br />

As you can see, the + (plus) operator generates a almost twice as much IL code to do the same thing as a string formatter! Do that a few thousand or so times and there could be a noticeable performance issue in your code. It is also slower to use the + (plus) operator for string concatenation. StringBuilder is a special case. While it generates more IL code than a string formatter, it is a lot faster.

So, what does this all mean?

For everyday string concatenation of two strings use either the + (plus) operator or a string formatter. Once you start concatenating more than two strings, you should use a string formatter. If you find yourself concatenating large amounts of string data then you should be using a StringBuilder for optimal performance.