Deserialized The Ramblings of a Web Architect

Some thoughts on string concatenation in C#

I recently stumbled into a blog entry on CodeProject.com that stated some things about string concatenation in C# that went against what I thought to be true, and it got me thinking.

From the article:

string sentence = "The " + "dog " + "ate " + "the " + "cat " + "all " + "day " + "for " + "for " + "fun.";

”That innocent looking line of code actually takes up much more processing power and memory than it appears to. If strings were combined in the ideal way, you would expect that the sentence would be the only string created from this operation. However, since each string is combined to its neighbor in succession, it turns out that 7 other strings are also created (shown in gray in the diagram above). The total amount of unnecessary memory allocations created from this operation is equal to the following equation, where N is the number of strings you are combining…”

But I knew that couldn’t be true, so I fired up Visual Studio and wrote a few simple tests, compiled and then analyzed the generated CIL.

First test:

Original C#:

public string createStringOne()
{
    return "The " + "dog " + "ate " + "the " + "cat " + "all " + "day " + "for " + "for " + "fun.";
}

Generated CIL:

.method public hidebysig instance string createStringOne() cil managed
{
    .maxstack 8
    L_0000: ldstr "The dog ate the cat all day for for fun."
    L_0005: ret
}

Second test:

Original C#:

public string createStringTwo()
{
    return "The dog ate the cat all day for for fun.";
}

Generated CIL:

.method public hidebysig instance string createStringTwo() cil managed
{
    .maxstack 8
    L_0000: ldstr "The dog ate the cat all day for for fun."
    L_0005: ret
}

Third test:

Original C#:

public string createStringThree()
{
    var sb = new StringBuilder();
    sb.Append("The ");
    sb.Append("dog ");
    sb.Append("ate ");
    sb.Append("the ");
    sb.Append("cat ");
    sb.Append("all ");
    sb.Append("day ");
    sb.Append("for ");
    sb.Append("for ");
    sb.Append("fun.");
    return sb.ToString();
}

Generated CIL:

.method public hidebysig instance string createStringThree() cil managed
{
    .maxstack 2
    .locals init (
        [0] class [mscorlib]System.Text.StringBuilder sb)
    L_0000: newobj instance void [mscorlib]System.Text.StringBuilder::.ctor()
    L_0005: stloc.0
    L_0006: ldloc.0
    L_0007: ldstr "The "
    L_000c: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0011: pop
    L_0012: ldloc.0
    L_0013: ldstr "dog "
    L_0018: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_001d: pop
    L_001e: ldloc.0
    L_001f: ldstr "ate "
    L_0024: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0029: pop
    L_002a: ldloc.0
    L_002b: ldstr "the "
    L_0030: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0035: pop
    L_0036: ldloc.0
    L_0037: ldstr "cat "
    L_003c: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0041: pop
    L_0042: ldloc.0
    L_0043: ldstr "all "
    L_0048: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_004d: pop
    L_004e: ldloc.0
    L_004f: ldstr "day "
    L_0054: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0059: pop
    L_005a: ldloc.0
    L_005b: ldstr "for "
    L_0060: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0065: pop
    L_0066: ldloc.0
    L_0067: ldstr "for "
    L_006c: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_0071: pop
    L_0072: ldloc.0
    L_0073: ldstr "fun."
    L_0078: callvirt instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
    L_007d: pop
    L_007e: ldloc.0
    L_007f: callvirt instance string [mscorlib]System.Object::ToString()
    L_0084: ret
}

Fourth test:

Original C#:

public string createStringFour()
{
    return new StringBuilder("The dog ate the cat all day for for fun.").ToString();
}

Generated CIL:

.method public hidebysig instance string createStringFour() cil managed
{
    .maxstack 8
    L_0000: ldstr "The dog ate the cat all day for for fun."
    L_0005: newobj instance void [mscorlib]System.Text.StringBuilder::.ctor(string)
    L_000a: callvirt instance string [mscorlib]System.Object::ToString()
    L_000f: ret
}

Fifth test:

Original C#:

public string createStringFive()
{
    string s = "The ";
    s += "dog ";
    s += "ate ";
    s += "the ";
    s += "cat ";
    s += "all ";
    s += "day ";
    s += "for ";
    s += "for ";
    s += "fun.";
    return s;
}

Generated CIL:

.method public hidebysig instance string createStringFive() cil managed
{
    .maxstack 2
    .locals init (
        [0] string s)
    L_0000: ldstr "The "
    L_0005: stloc.0
    L_0006: ldloc.0
    L_0007: ldstr "dog "
    L_000c: call string [mscorlib]System.String::Concat(string, string)
    L_0011: stloc.0
    L_0012: ldloc.0
    L_0013: ldstr "ate "
    L_0018: call string [mscorlib]System.String::Concat(string, string)
    L_001d: stloc.0
    L_001e: ldloc.0
    L_001f: ldstr "the "
    L_0024: call string [mscorlib]System.String::Concat(string, string)
    L_0029: stloc.0
    L_002a: ldloc.0
    L_002b: ldstr "cat "
    L_0030: call string [mscorlib]System.String::Concat(string, string)
    L_0035: stloc.0
    L_0036: ldloc.0
    L_0037: ldstr "all "
    L_003c: call string [mscorlib]System.String::Concat(string, string)
    L_0041: stloc.0
    L_0042: ldloc.0
    L_0043: ldstr "day "
    L_0048: call string [mscorlib]System.String::Concat(string, string)
    L_004d: stloc.0
    L_004e: ldloc.0
    L_004f: ldstr "for "
    L_0054: call string [mscorlib]System.String::Concat(string, string)
    L_0059: stloc.0
    L_005a: ldloc.0
    L_005b: ldstr "for "
    L_0060: call string [mscorlib]System.String::Concat(string, string)
    L_0065: stloc.0
    L_0066: ldloc.0
    L_0067: ldstr "fun."
    L_006c: call string [mscorlib]System.String::Concat(string, string)
    L_0071: stloc.0
    L_0072: ldloc.0
    L_0073: ret
}

Results:

So as you can see, the first two methods are essentially the same thing!  It doesn't matter if we concatenate one large string from several smaller strings if (and only if) it happens on one operation.  If concatenation is done using multiple operations, then it does in fact incur a performance and memory hit.

The use of a StringBuilder in this case (where there are only a small handful of small strings) serves no purpose as far as performance is concerned.

But… how are they equal!?

Compiler optimizations!  The C# compiler is an incredible piece of software that can look at your code and “fix” it.  It is important when working on code optimizations like the one in the article mentioned above that developers take into consideration compiler optimizations that may alter the code that they think is poorly written.

Comparing while() loops with for() loops in C#

There is always a lot of debate about the speed and performance of loops in any language.  I was curious to see what the differences were between a for() loop and a while() loop in C# and ultimately the .NET CLR.

What I found was no big surprise to me, as it simply confirms what I have been reading for many years.  While loops are simply faster and less complex than for loops.  I did a very simple test to verify this.  I created two loops that contained empty bodies.  You can see them below:

public void doFor()
{
    int i = 0;
    int len = 100;

    for (i = 0; i < len; i++)
    {

    }
}

public void doWhile()
{
    int i = 100;
    while (i-- == 0)
    {

    }
}

As you can see, both of these loops are as basic as they can be and have no inner bodies to complicate the CIL.  Lets take a look at the generated CIL for each of them.

The generated CIL for a for() loop

.method public hidebysig instance void doFor() cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 i,
        [1] int32 len)
    L_0000: ldc.i4.0
    L_0001: stloc.0
    L_0002: ldc.i4.s 100
    L_0004: stloc.1
    L_0005: ldc.i4.0
    L_0006: stloc.0
    L_0007: br.s L_000d
    L_0009: ldloc.0
    L_000a: ldc.i4.1
    L_000b: add
    L_000c: stloc.0
    L_000d: ldloc.0
    L_000e: ldloc.1
    L_000f: blt.s L_0009
    L_0011: ret
}

The generated CIL for a while() loop

.method public hidebysig instance void doWhile() cil managed
{
    .maxstack 3
    .locals init (
        [0] int32 i)
    L_0000: ldc.i4.s 100
    L_0002: stloc.0
    L_0003: ldloc.0
    L_0004: dup
    L_0005: ldc.i4.1
    L_0006: sub
    L_0007: stloc.0
    L_0008: brfalse.s L_0003
    L_000a: ret
}

The results are in and there is no surprise.

As you can see, the generated CIL for a for() loop is larger by 6 instructions. Furthermore, in this code the for() loop initializes 2 local variables rather than 1 (but this may vary depending on your code).

What does it all mean?

Probably nothing.  6 more instructions and an additional variable declaration will in most cases have no impact on the performance, even if you are measuring in microseconds.  I am curious to see what the resulting difference between the loops above would be in other languages.