How come this code is valid C# code?

Question

Possible Duplicate:
C#: Why is adding null to a string legal?

Here is the valid C# code:

var samsung= "xyz" + null + null + null + null + "890";  // xyz890

And this is the invalid C# code:

var iphone= null.ToString(); // compiler error

Why and how is the first statement valid and second is invalid ?

Answer 1

The + operator is used to concatenate strings, and since null is an instance of the string class it can be used as an argument to the operator. "xyz" + null ends up returning the string "xyz", so this process is just repeated until you actually add "890".

While null can be used as a string object for an argument to a method, you cannot actually call methods on it because there's nothing to process the method call.

Think of methods as a way for an object to process an external request and things make a bit more sense. You can send a request to an object with null as an argument for what to process, but you can't actually ask null to process something.

Answer 2

The C# compiler thinks of null in concatenations as an empty string.

 var samsung= "xyz" + null + null + null + null + "890";

equals

 var samsung= "xyz" + ""+ ""+ ""+ ""+ "890";

When you try to call null.toString() you are essentially trying to call a method on a null object, which (if it compiled) would always cause a NullReferenceException.

Answer 3

With the first line, you are concatinating strings. null is nothing, so essentially you are getting xyz890. It's like doing 1+0+0+0+4 But with your second, you're call ToString() on a null. null is nothing, so there's nothing there to call ToString() on. You're attempting to call a method on an non-initialized variable.

Answer 4

Since string is a reference type, null can be implicitly converted to string. And in first case sequence of + operators just is transformed to String.Concat(obj1, obj2, obj3, ...)

To make your code compile you can call Convert.ToString:

var iphone = Convert.ToString(null);

Answer 5

You can think of the + operator as a global static function like so:

+(string leftHandSide, string rightHandSide) {
  if (leftHandSide == null)
     leftHandSide = string.Empty;
  if (rightHandSide == null)
     rightHandSide = string.Empty;
  string returnValue;

  // concatenate string

  return returnValue;
}

Since this string concatenation method is static it does not require an instance to call it, it handles the null values. However when you try to call ToString on null there is no instance of an object so there is no ToString mehthod to call, hence the exception.

Answer 6

This is by design. You could read the C# Language Specification. Quote:

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.

[...]

So, as others have said, think of + as a kind of method that takes in two arguments and is OK with one or both of them being null.

Answer 7

Because you can't call a method on a null reference in any case, so the compiler doesn't allow it. In your first case, the compiler will pre-compile the string constant to "xyz890" so it is a legal assignment.

In general, the + operator for string compiles to String.Concat(s1, s2, ...) which supports null arguments.

To be more precise on the second case, the actual problem isn't that it's a null pointer, it's that there is no type to bind the method to. As pointed out in other comments, you can cast null to any reference type and it compiles just fine:

((string)null).ToString();   // compiles, but fails at run-time.

Answer 8

The + operator will be translated to a static function that looks much like:

public static string Concat(string first, string second) {...}

Passing null as a parameter to a function isn't a problem; it gets passed just fine. That function happens to check that neither of the parameters are null before concatting them; if any of the parameters are null they are treated as empty strings so as to not cause exceptions. The key point here is that no instance members of the strings are called until they are first null checked by this function.

As for null.ToString() calling an instance function on anything that evaluates to null at compile time results in an exception. This is the very definition of that case.

Answer 9

If you look at the IL you'll see that the compiler is smart enough to just drop the null values and creates a concatenated string. As mentioned earlier you can't do a null.ToString(); you can do string.Empty or assign a string to be null.

.method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       8 (0x8)
  .maxstack  1
  .locals init ([0] string samsung)
  IL_0000:  nop
  IL_0001:  ldstr      "xyz890"        //null has been removed by compiler.  
  IL_0006:  stloc.0
  IL_0007:  ret
} // end of method Program::Main 

EDIT
Expand on Nielson's comment. As null represents an nil reference it might be fair to say that the way string concat is handled is C# permits such as operation. I'd fathom it uses byte array building which would omit the null values, thus simply making it appear as if it's concating null.