Where in memory are nullable types stored?

by

First off, Nullable<int> is just a shorthand for something like:

struct Nullable<T> 
{
    bool hasValue;
    T value;
}

Plus all the constructors, accessors, and so on. That’s all it is — a nullable int is an ordinary int plus a flag that says whether the int is null or not. All the rest is compiler magic that treats “null” as a valid value; all “null” does with a nullable type is makes you one of those structs with the flag set to false.

So now that we have that out of the way, your question is “where do they go in memory”? They go the same place that any other structs go in memory: where the runtime and compiler believe to be the best place given the lifetime of the memory.

Most structs go on the heap. Anyone who tells you that “structs always go on the stack” doesn’t actually know what they are talking about; our documentation does not say that and it is not true. Structs only go on the temporary memory pool, aka “the stack”, when they are local variables or temporaries, and the local variables are not closed-over outer variables of an anonymous method or lambda, and the local variables are not in an iterator block. All other structs go on the heap in our implementation.

Note also that there is no requirement whatsoever that an implementation of the CLI use “the stack” to make their temporary pool. The classic JScript memory manager, for example, stores its temporary pool on the heap. (Though of course the JScript runtime engine is not an implementation of the CLI; I’m merely pointing out that one can design a managed runtime engine that puts no user data whatsoever on “the stack”.) Logically it is a stack data structure, but that data structure is not store on “the” stack, it’s just a stack structure allocated on the heap.

I have to ask: why do you care? The CLR manages memory on your behalf. Why do you care where nullable types go? They go where they live long enough to be useful to you; you don’t have to worry about that.

More Related Contents:

  1. Nullable types and the ternary operator: why is `? 10 : null` forbidden? [duplicate]
  2. How to check if an object is nullable?
  3. What is the difference between Nullable.HasValue or Nullable != null?
  4. Nullable type is not a nullable type?
  5. What does “DateTime?” mean in C#?
  6. How to parse a string into a nullable int
  7. What are lifted operators?
  8. Why GetType returns System.Int32 instead of Nullable? [duplicate]
  9. Invalid cast from ‘System.Int32’ to ‘System.Nullable`1[[System.Int32, mscorlib]]
  10. Optional return in C#.Net
  11. How is the boxing/unboxing behavior of Nullable possible?
  12. Are nullable types reference types?
  13. Boxing / Unboxing Nullable Types – Why this implementation?
  14. Why doesn’t the conditional operator correctly allow the use of “null” for assignment to nullable types? [duplicate]
  15. how are nullable types implemented under the hood in .net?
  16. Sorting Win Form CheckListbox [closed]
  17. Deciding between HttpClient and WebClient
  18. Running multiple async tasks and waiting for them all to complete
  19. Converting SVG to PNG using C# [closed]
  20. Is there a Lower Bound function on a SortedList?
  21. Why no ICloneable?
  22. How to insert characters to a file using C#
  23. How to set selected value from Combobox?
  24. Is there a possibility to differ virtual printer from physical one?
  25. Why does C#/CLR not support method override co/contra-variance?
  26. Parsing a Auto-Generated .NET Date Object with Javascript/JQuery
  27. Which C# method overload is chosen?
  28. Explanation of Func
  29. Repository Pattern, POCO, and Business Entities
  30. Two Types not equal that should be

Leave a Comment