C# Nullable – How Nullable Types Work Behind the Scenes

.netc++

I'm curious to know how the Nullable type works behind the scenes. Is it creating a new object(objects can be assigned null) with a possible value of null?

In the example we use a Nullable<int>, is their some kind of implicit conversion from an object to an int and vice versa when you assign it a null value?

Also I know how this can be created manually, is there a benfit from using the Nullable type as opposed to creating it ourself?

Best Answer

The nullable type is a struct consisting of two fields: a bool and a T. When the value is null, the bool is false and the T has the default value. When the value is not null, the bool is true.

There are two main benefits to using Nullable as compared to implementing the functionality yourself. There's the language support, as described in more detail in ChaosPandion's answer, and there's the fact that boxing (converting to an object) will automatically remove the nullable "wrapper", leaving either a null reference or the plain T object.z

Related Solutions

C# .NET – Handling Null Literal Assignment to System.Nullable

The statement:

int? myInt = null;

Gets compiled as:

  .locals init (valuetype [mscorlib]System.Nullable`1<int32> V_0)
  IL_0000:  ldloca.s   V_0
  IL_0002:  initobj    valuetype [mscorlib]System.Nullable`1<int32>

Which, according to the MSDN, means «Initialize each field of the value type at a specified address to a null reference or a 0 of the appropriate primitive type.»

So there's no constructor or conversion here. HasValue will return false, and trying to get its Value will throw an InvalidOperationException. Unless you use GetValueOrDefault of course.

C# .NET – How Nullable Types are Implemented Under the Hood

Ultimately, they are just a generic struct with a bool flag - except with special boxing rules. Because structs are (by default) initialized to zero, the bool defaults to false (no value):

public struct Nullable<T> where T : struct {
    private readonly T value;
    private readonly bool hasValue;
    public Nullable(T value) {
        this.value = value;
        hasValue = true;
    }
    public T Value {
        get {
           if(!hasValue) throw some exception ;-p
           return value;
        }
    }
    public T GetValueOrDefault() { return value; }
    public bool HasValue {get {return hasValue;}}
    public static explicit operator T(Nullable<T> value) {
        return value.Value; }
    public static implicit operator Nullable<T>(T value) {
        return new Nullable<T>(value); }
}

Extra differences, though:

special boxing rules (you can't normally do this)
special C# rules for comparing to null etc
"lifted" operators in C# (and in .NET via EqualityComparer<T>, Comparer<T> etc)
special rules on generic type constraints (to prevent Nullable<Nullable<T>>)

Best Answer

Related Solutions

C# .NET – Handling Null Literal Assignment to System.Nullable

C# .NET – How Nullable Types are Implemented Under the Hood

Related Question