Why can assign “null” to nullable types

.NET Framework 2.0 introduces “nullable” variables, from its meaning, nullable types allow a type object instance to be assigned with value, or a null reference (null in C#, Nothing in Visual Basic). While referencing the nullable types, developers can check if the instance contains value (by invoke HasValue property) then get the underlying value (by invoke Value property). This mechanism builds a more safer way to interoperate with the types that is transferred between different systems, and reduce the NullReferenceException occurrence in action.

Nullable types are value-typed generic types, which means the underlying type of the nullable type is defined through the type parameter, furthermore, the type parameter can just be value type. For example, you cannot define a nullable variable of underlying type “string”, because “string” is a reference type.

However you will find it looks very strange – though the type parameter is restricted to value types, we can still assign “null” to nullable types. This code may always work in C#:

int? nullableInt = null;

The value type variables cannot be assigned to null, if you are trying to do so on int type, you may get a compiler error: cannot convert source type “null” to target type “int”.

So why it is working on nullable types?

To conclude this problem, let’s think over – is it reasonable to use implicit operator overloading to implement this? The answers is yes. Operator overloading can help to convert source type to target type implicitly (using assignment statement and assignment operator “=”) or explicitly (use explicitly conversion operator “()”), you need to overload implicit operators to allow a reference type to assign to a value type, you may need to programmatically create a new instance of the target type, doing something with source type, clone properties from source type then return the instance of target type. By using the implicit operator, you gain the ability to implicitly assign instance of any other type to your source type, for example, you can use the following code to initialize a Complex object if defined implicit operators:

Complex complexNumber = "4 + 6i";

But the nullable type doesn’t use implicit operators to do so. To prove this, let’s take a look at the source code of System.Nullable<T>.

As you see, the implicit operator T and explicit operator T doesn’t handle the null particularly. So how does C# compiler translate the null reference to a nullable object? Let’s see the IL code for this statement.

The testing program code is showing below.

The IL code for this program is here:

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 3
    .locals init (
        [0] valuetype [mscorlib]System.Nullable`1<int32> testNullableInt,
        [1] string testString)
    L_0000: nop 
    L_0001: ldloca.s testNullableInt
    L_0003: initobj [mscorlib]System.Nullable`1<int32>
    L_0009: ldnull 
    L_000a: stloc.1 
    L_000b: ldstr "Int: {0}, String: {1}"
    L_0010: ldloc.0 
    L_0011: box [mscorlib]System.Nullable`1<int32>
    L_0016: ldloc.1 
    L_0017: call void [mscorlib]System.Console::WriteLine(string, object, object)
    L_001c: nop 
    L_001d: ret 
}

See Line “L_0001” and “L_0003”, IL loads the address of the local variable at index 0 (testNullableInt) on to the evaluation stack, then calls the “initobj” instruction. “initobj” instruction initializes an object with a null reference or an appropriate default value of the specific primitive type. Comparing with line “L_0009” and “L_000a”, IL loads a null object on the top of the evaluation stack and store this to the local variable of index 1 (testString). You may now clear enough – the IL treats the null reference assignment to the nullable object as particular, use “initobj” instruction to initialize the nullable object. The testString is a reference type object, thus the IL loads a “null” object and can directly assign to testString.

Conclusion: Null reference assignment to a nullable type will be treated separately during compilation, different introductions will be used in different context of the null reference assignment statements.