Boxing / Unboxing Nullable Types – Why this implementation?

by

I remember this behavior was kind of last minute change. In early betas of .NET 2.0, Nullable<T> was a “normal” value type. Boxing a null valued int? turned it into a boxed int? with a boolean flag. I think the reason they decided to choose the current approach is consistency. Say:

int? test = null;
object obj = test;
if (test != null)
   Console.WriteLine("test is not null");
if (obj != null)
   Console.WriteLine("obj is not null");

In the former approach (box null -> boxed Nullable<T>), you wouldn’t get “test is not null” but you’d get “object is not null” which is weird.

Additionally, if they had boxed a nullable value to a boxed-Nullable<T>:

int? val = 42;
object obj = val;

if (obj != null) {
   // Our object is not null, so intuitively it's an `int` value:
   int x = (int)obj; // ...but this would have failed. 
}

Beside that, I believe the current behavior makes perfect sense for scenarios like nullable database values (think SQL-CLR…)

Clarification:

The whole point of providing nullable types is to make it easy to deal with variables that have no meaningful value. They didn’t want to provide two distinct, unrelated types. An int? should behaved more or less like a simple int. That’s why C# provides lifted operators.

So, when unboxing a value type into a nullable version, the CLR must allocate a Nullable<T> object, initialize the hasValue field to true, and set the value field to the same value that is in the boxed value type. This impacts your application performance (memory allocation during unboxing).

This is not true. The CLR would have to allocates memory on stack to hold the variable whether or not it’s nullable. There’s not a performance issue to allocate space for an extra boolean variable.

More Related Contents:

  1. How do ValueTypes derive from Object (ReferenceType) and still be ValueTypes?
  2. How to check if an object is nullable?
  3. Performance surprise with “as” and nullable types
  4. Stack capacity in C#
  5. What does “DateTime?” mean in C#?
  6. Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates? [duplicate]
  7. How to parse a string into a nullable int
  8. Static Generic Class as Dictionary
  9. What are lifted operators?
  10. Why C# is not allowing non-member functions like C++
  11. Resolve assembly references from another folder
  12. Why check this != null?
  13. explicitly cast generic type parameters to any interface
  14. Initialization of instance fields vs. local variables
  15. Try-catch speeding up my code?
  16. Hosting CLR in Delphi with/without JCL – example
  17. Should we always include a default constructor in the class?
  18. Why GetType returns System.Int32 instead of Nullable? [duplicate]
  19. Invalid cast from ‘System.Int32’ to ‘System.Nullable`1[[System.Int32, mscorlib]]
  20. Optional return in C#.Net
  21. Why does C#/CLR not support method override co/contra-variance?
  22. .NET 4.0 and the dreaded OnUserPreferenceChanged Hang
  23. Are nullable types reference types?
  24. Are static indexers not supported in C#? [duplicate]
  25. What is the maximum length of a C#/CLI identifier?
  26. Simplest way to make cross-appdomain call?
  27. Can you have multiple enum values for the same integer? [duplicate]
  28. Retrieve JIT output
  29. Why doesn’t the conditional operator correctly allow the use of “null” for assignment to nullable types? [duplicate]
  30. how are nullable types implemented under the hood in .net?

Leave a Comment