I use the "bool" type for variables as I was used to in C++, and I try to put the values of functions or properties I expect to be boolean into my variable. However I often encounter cases where the result type is "bool?" and not "bool" and the implicit casting fails.
What is the difference between the two and when is each used? Also, should I use "bool?" as the type for my variable? Is this the best practice?
The ?
symbol after a type is only a shortcut to the Nullable type, bool?
is equivalent to Nullable<bool>
.
bool
is a value type, this means that it cannot be null
, so the Nullable type basically allows you to wrap value types, and being able to assign null
to them.
bool?
can contain three different values: true
, false
and null
.
Also, there are no short-circuiting operators (&& ||) defined for bool?
Only the logical AND, inclusive OR, operators are defined and they behave like this:
x y x & y x | y
true true true true
true false false true
true null null true
false true false true
false false false false
false null false null
null true null true
null false false null
null null null null
The Nullable type is basically a generic struct, that has the following public properties:
public struct Nullable<T> where T: struct
{
public bool HasValue { get; }
public T Value { get; }
}
The HasValue
property indicates whether the current object has a value, and the Value
property will get the current value of the object, or if HasValue is false, it will throw an InvalidOperationException.
Now you must be wondering something, Nullable is a struct, a value type that cannot be null, so why the following statement is valid?
int? a = null;
That example will compile into this:
.locals init (valuetype [mscorlib]System.Nullable`1<int32> V_0)
IL_0000: ldloca.s V_0
IL_0002: initobj valuetype [mscorlib]System.Nullable`1<int32>
A call to initobj, which initializes each field of the value type at a specified address to a null reference or a 0 of the appropriate primitive type.
That's it, what's happening here is the default struct initialization.
int? a = null;
Is equivalent to:
Nullable<int> a = new Nullable<int>();