How does a Nullable<T> type work behind the scenes?

Question

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?

Answer 1

It's actually quite simple. The compiler gives you a hand with the syntax.

// this
int? x = null;
// Transformed to this
int? x = new Nullable<int>()

// this
if (x == null) return;
// Transformed to this
if (!x.HasValue) return;

// this
if (x == 2) return;
// Transformed to this
if (x.GetValueOrDefault() == 2 && x.HasValue) return;

Answer 2

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