How does appending to a null string work in C#?

Question

I was surprised to see an example of a string being initialised to null and then having something appended to it in a production environment. It just smelt wrong.

I was sure it would have thrown a null object exception but this greatly reduced example also works:

string sample = null;
sample += "test";
// sample equals "test"

*Note the original code I found sets a string property to null and appends to it elsewhere so answers involving the compiler optimizing out the null at compile-time are irrelevant.

Can someone explain why this works without error?

Follow-up:

Based on Leppie's answer I used Reflector to see what is inside string.Concat. It is now really obvious why that conversion takes place (no magic at all):

public static string Concat(string str0, string str1)
{
    if (IsNullOrEmpty(str0))
    {
        if (IsNullOrEmpty(str1))
        {
            return Empty;
        }
        return str1;
    }
    if (IsNullOrEmpty(str1))
    {
        return str0;
    }
    int length = str0.Length;
    string dest = FastAllocateString(length + str1.Length);
    FillStringChecked(dest, 0, str0);
    FillStringChecked(dest, length, str1);
    return dest;
}

**Note: the specific implementation I was investigating (in the .Net library by Microsoft) does not convert to empty strings as is suggested by the C# standards and most of the answers, but uses a few tests to shortcut the process. The end result is the same as if it did but there you go :)

Solution 1

the + operator for strings are just shorthand for string.Concat which simply turns null arguments into empty strings before the concatenation.

Update:

The generalized version of string.Concat:

public static string Concat(params string[] values)
{
    int num = 0;
    if (values == null)
    {
        throw new ArgumentNullException("values");
    }
    string[] array = new string[values.Length];
    for (int i = 0; i < values.Length; i++)
    {
        string text = values[i];
        array[i] = ((text == null) ? string.Empty : text);
        num += array[i].Length;
        if (num < 0)
        {
            throw new OutOfMemoryException();
        }
    }
    return string.ConcatArray(array, num);
}

Solution 2

The relevant citation should be ECMA-334 §14.7.4:

String concatenation:

string operator +(string x, string y);
string operator +(string x, object y);
string operator +(object x, string y);  

The binary + operator performs string concatenation when one or both operands are of type string. If an operand of string concatenation is null, an empty string is substituted. Otherwise, any non-string operand is converted to its string representation by invoking the virtual ToString method inherited from type object. If ToString returns null, an empty string is substituted.

Solution 3

it is because

In string concatenation operations, the C# compiler treats a null string the same as an empty string, but it does not convert the value of the original null string.

From How to: Concatenate Multiple Strings (C# Programming Guide)

The binary + operator performs string concatenation when one or both operands are of type string. If an operand of string concatenation is null, an empty string is substituted. Otherwise, any non-string argument is converted to its string representation by invoking the virtual ToString method inherited from type object. If ToString returns null, an empty string is substituted.

From Addition operator

Solution 4

Here is what your code gets compiled to

string sample = null;
sample += "test";

is compiled to this IL code:

.entrypoint
  // Code size       16 (0x10)
  .maxstack  2
  .locals init ([0] string sample)
  IL_0000:  nop
  IL_0001:  ldnull
  IL_0002:  stloc.0
  IL_0003:  ldloc.0
  IL_0004:  ldstr      "test"
  IL_0009:  call       string [mscorlib]System.String::Concat(string,
                                                              string)
  IL_000e:  stloc.0
  IL_000f:  ret

And String.Concat takes care of NULL string.

View more solutions

Comments

[Timothy]

A somewhat unexpected side effect: string sample = null; sample += null; //sample == string.Empty Then again, I'm not sure what I would have expected null + null to be...

[Gone Coding]

@Timothy: given the source code for Concat above, that is exactly what I would expect. IsNullOrEmpty == true on both parameters returns the Empty string constant. Does seem odd though I agree :)

[Gone Coding]

Where did you get that reference? The "compiler" should have no knowledge of the runtime values. Thanks

[Gone Coding]

+1: Thanks for that. Based on your answer I decompiled String.Concat (added above) and it all makes sense now. Cheers.

[Gone Coding]

Thanks for the update. Typical that Microsoft's explanation actually makes it more confusing! :)

[Random832]

@HiTech Magic The compiler does do concatenation of constant values (string literals and the null literal), replacing the concatenation expression with a string literal of the whole string. It also eliminates null literals from concatenation expressions.

[KeithS]

Obviously this is the right answer for the OP, but was it ever true in .NET that "abc" + null == null? Classically, null is a "non-value", and so operations on a generic "null" are inconclusive. I was always taught that "null isn't empty", and by definition this is correct; null != String.Empty, which is why we have String.IsNullOrEmpty().

[Andy]

@KeithS, this is simply because the + operator for a string is defined as syntatic sugar to call string.Concat. If you remove the +operator definition on string, you wouldn't be able to use + at all. So its not like addition is defined for everything and the compiler magically figures it out (as some languages do). C# requires an explicit +operator definition to use the operator.

[KeithS]

@Andy: That wasn't the answer to the question I asked. The question was, did .NET's string concatenation ever behave differently than it does currently?

[leppie]

@HiTechMagic: As per the other answer that should not happen. Was optimization on? What version of .NET?

[leppie]

@HiTechMagic: When using literal null, it gets optimized away, as it can :)

[Gone Coding]

The example is greatly simplified. The actual situation had the null assignment to a member in a constructor, and the += happens much later, so optimisation is not a factor. Thanks anyway

[Gone Coding]

While that was the aim of the language it appears the MS coders were happy to write their logic based on null-ness of the parameters instead (see the decomp above). I guess they felt it was more optimal.

[leppie]

@HiTechMagic: I think there is a misunderstanding issue here. You should not concern yourself with the internals of string.Concat. The way I specified it, is how it behaves. And that is indeed how it is implemented in the generalized version string.Concat(params string[] values).

[Rasmus Faber]

@HiTech Magic: I believe the implementation matches the specification. Note the text I emphasized: "If an operand [..] is null, an empty string is substituted". Exactly what we see in the behavior and the decompilation.

[Gone Coding]

Sorry I must be missreading the decomp, as at no point does it substitute empty strings. The end result is the same as if it did, and I realise I am just being pedantic, but there you go. Thanks

[Gone Coding]

I realise I was being pedantic (and that leaving out the .Net tag was a big mistake) :) I will edit my question for clarity. Thanks.

[Johan Boulé]

@Andy Actually, where is the explicit definition of operator+ or operator+= in C# ? People have commented that "+=" is a magical syntactic sugar for string.Concat. I can't help but contrast this with C++'s std::string which explicitly defines all operators for strings, since string isn't a fundamental type in that language.

[Andy]

@JohanBoule Its in the compiler: ericlippert.com/2013/06/17/…