Why doesn't attempting to add to a null value throw an InvalidOperationException?

int? x = null;
x = x + 1;  // Works, but x remains null

I would expect the com开发者_如何学运维piler to attempt to cast x as an int, but apparently it does not.

Edit by 280Z28: Changed NullReferenceException to InvalidOperationException, which is what Nullable<T>.Value throws when HasValue is false.

This is per the specification for lifted binary operators. From §7.2.7:

For the binary operators

+ - * / % & | ^ << >>

a lifted form of an operator exists if the operand and result types are all non-nullable value types. The lifted form is constructed by adding a single ? modifier to each operand and result type. The lifted operator produces a null value if one or both operands are null (an exception being the & and | operators of the bool? type, as described in §7.10.3). Otherwise, the lifted operator unwraps the operands, applies the underlying operator, and wraps the result.

The reasoning is this: you are to think of null for a nullable type as meaning "I do not know what the value is." What is the result of "I don't know" plus one? "I don't know." Thus, the result should be null.

Nullables are never actually null references. They are always object references. Their internal classes override the == and = operators. If they are being compared to null, they'll return the value of the HasValue property.

Why would you expect the compiler to cast it as int when you've declared it as Nullable? The compiler is doing what you've told it to do and null +1 = null.

You'll have to cast explicitly or check x.HasValue before attempting to add an int.

The reason for this is that the compiler creates a 'lifted' operator for nullable types - in this case it is something like:

public static int? operator +(int? a, int? b)
{
    return (a == null || b == null) ? (int?)null : a.Value + b.Value
}

I think if you try to assign the result to a non-nullable value, the compiler will be forced to use the non-nullable overload and convert x to an int.

e.g. int i = x + 1;  //throws runtime exception

Unfortunately it doesn't. The X in x = X + 1 is null as in the first line so you're adding 1 to null, which equals null.

As it's a nullable int, you can use x.HasValue to check if it has a value, and then x.Value to get the actual int value out

Regardless of whether x is actually never null, that's not even the point.

The point is, when have you ever seen a NullReferenceException when trying to perform an addition?

The following example doesn't throw a NullReferenceException either and is perfectly valid.

string hello = null;
string world = "world";
string hw = hello+world;

You would only get a NullReferenceException if you try to access a member on an object that is null.

int? can never be null because it is a struct. Structs live on the stack and the stack does not handle null well.

See What is a NullPointerException, and how do I fix it?

Also, the nullable types have 2 very useful properties : HasValue, Value

This code:

        if (x != null)
        {
            return (int) x;
        }

Should be refactored to this:

        if (x.HasValue)
        {
            return x.Value;
        }