the advantage of nullable variable in memory allocation C#

Question

I had read some article explain about nullable<T> type variable, so far I not found any article explain the effect of nullable<T> type variable compare with non-nullable type variable.

is that nullable<T> type variable will consume lesser memory allocation? or both of them is same

add-on

so we are not necessary to use nullable<T> for every variable when it have no possibility to be null?

Answer 1

Assuming you are talking about the Nullable<T> type, then it will always use more memory than the equivalent non-nullable type.

Both are value types and so can be stored e.g. on the stack when used as parameters or local variables, or as individual elements within a contiguous block of memory (i.e. as an array), which can in some situations improve memory usage characteristics. In other words, with Nullable<T> you get some reference type semantics, without some of the storage-related drawbacks.

But an instance of Nullable<T> necessarily contains both the nominal value (even when the effective value of the instance is null, the storage for the non-nullable type still exists), along with a flag indicating whether or not the instance should be treated as a null value. Obviously "value plus a flag" will take more memory than just "value".

Note that the implementation of Nullable<T>, at least from a storage perspective, looks like this:

public struct Nullable<T> where T : struct
{
    private bool hasValue; 
    internal T value;
}

You can clearly see the value and the flag here. The non-nullable equivalent for any variable of type T would of course have only the value. The extra bool represents an additional memory requirement.

Thus, for any value type T, an instance of Nullable<T> will take up more memory than an instance of T.