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

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?

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.

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.