The Nullable<T>
type is defined as a struct
. In .Net, you can't assign null
to a struct
because structs
are value types that cannot be represented with null
(with the exception of Nullable<T>
).
int i = null; // won't compile - we all know this
int? i = null; // will compile, and I'm glad it does, and it should compile, but why?
How did Nullable<T>
become an exception to the rule "You can't assign null
to a value type?" The decompiled code for Nullable<T>
offers no insights as of to how this happens.
Best Answer
By changing the language, basically. The
null
literal went from being "a null reference" to "the null value of the relevant type".At execution time, "the null value" for a nullable value type is a value where the
HasValue
property returnsfalse
. So this:is equivalent to:
It's worth separating the framework parts of
Nullable<T>
from the language and CLR aspects. In fact, the CLR itself doesn't need to know much about nullable value types - as far as I'm aware, the only important aspect is that the null value of a nullable value type is boxed to a null reference, and you can unbox a null reference to the null value of any nullable value type. Even that was only introduced just before .NET 2.0's final release.The language support mostly consists of:
?
soint?
is equivalent toNullable<int>
null
??
) - which isn't restricted to nullable value types