string = string + int: What's behind the scenes?

Question

In C# you can implicitly concatenate a string and let's say, an integer:

string sth = "something" + 0;

My questions are:

1. Why, by assuming the fact that you can implicitly concatenate a string and an int, C# disallows initializing strings like this:

   string sth = 0; // Error: Cannot convert source type 'int' to target type 'string'
   

2. How C# casts 0 as string. Is it 0.ToString() or (string)0 or something else?

3. How to find an answer of the previous question?

Answer 1

It compiles to a call to String.Concat(object, object), like this:

string sth = String.Concat("something", 0);

(Note that this particular line will actually be optimized away by the compiler)

This method is defined as follows: (Taken from the .Net Reference Source)

    public static String Concat(Object arg0, Object arg1) {
        if (arg0==null) {
            arg0 = String.Empty; 
        }

        if (arg1==null) { 
            arg1 = String.Empty;
        } 
        return Concat(arg0.ToString(), arg1.ToString());
    }

(This calls String.Concat(string, string))

---

To discover this, you can use ildasm, or Reflector (in IL or in C# with no optimizations) to see what the + line compiles to.

Answer 2

This is specified in section 7.8.4 of the C# 4 spec:

For an operation of the form x + y, binary operator overload resolution (§7.3.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined addition operators are listed below. For numeric and enumeration types, the predefined addition operators compute the sum of the two operands. When one or both operands are of type string, the predefined addition operators concatenate the string representation of the operands.

The last sentence is the most relevant one to this situation.

Then later:

String concatenation

string operator +(string x, string y);

string operator +(string x, object y);

string operator +(object x, string y);

These overloads of the binary + operator perform string concatenation. 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.

That specifies how the integer is converted into a string.

And the result:

The result of the string concatenation operator is a string that consists of the characters of the left operand followed by the characters of the right operand. The string concatenation operator never returns a null value.

The actual means of performing concatenation is implementation-specific, but as noted in other answers, the MS implementation uses string.Concat.