Nullable bool in C# might sometimes feel a bit of a hassle to work with. I’m here to give you a few tips that took me embarrassingly long to pick up on. I’m hoping this saves you some hassle too.

HasValue and Value

These properties are present on Nullable<T> and have been since generics where introduced. It took me too long to notice them, so here they are. No need to write

bool? nullableBool = true; bool regularBool; if (nullableBool != null) { regularBool = (bool)nullableBool; } 

when you can write

bool? nullableBool = true; bool regularBool; if (nullableBool.HasValue) { regularBool = nullableBool.Value; } 

HasValue returns true if nullableBool is not null and Value returns a regular bool if nullableBool is not null.

Value also works a lot better when chaining methods:

bool? nullableBool = true; ((bool)nullableBool).ToString(); // or, simply nullableBool.Value.ToString(); 

I think the second option is a lot more readable.

GetValueOrDefault

This method on Nullable<T> might not always save characters, but it’s very clear in it’s intent, which I believe accounts for a lot.GetValueOrDefault makes it clear what your code does.So instead of the generic null coalescing

bool? nullableBool = true; bool regularBool; if (nullableBool ?? false) { regularBool = nullableBool.Value; } 

you can explicitly say that you want a default value

bool? nullableBool = true; bool regularBool; if (nullableBool.GetValueOrDefault(false)) { regularBool = nullableBool.Value; } 

As I said, GetValueOrDefault doesn’t necessarily save on characters, but it’s clearly states what you want. This too works better when chaining methods:

bool? nullableBool = true; (nullableBool ?? false).ToString(); // alternatively nullableBool.GetValueOrDefault(false).ToString(); 

Direct variant checking

Again, this is one of those things that took me too long to figure out, so here goes. A simple boolean check might look like this:

bool regularBool; if (regularBool) { // some code... } 

but that doesn’t work with a bool?, so I used to do something like this

bool? nullableBool = true; if (nullableBool.HasValue && nullableBool.Value) { // some code... } 

or

bool? nullableBool = true; if (nullableBool ?? false) { // some code... } 

Turns out, you can just do this instead:

bool? nullableBool = true; if (nullableBool == true) { // some code... } 

nullableBool == true will evaluate to false if nullableBool is either false or null, in other words: not true. It seems so obvious in retrospect, but I’d become so accustomed to writing if (regularBool) ..., instead of if (regularBool == true) ..., that it didn’t occur to me to write it out in full for bool?s.

The other Nullable<T>s

This does work for the other nullable primitive types too. You can for example shorten this

int? nullableInt = null; int regularInt; if (nullableInt.HasValue && nullableInt == 100) { regularInt = nullableInt.Value; } 

to

int? nullableInt = null; int regularInt; if (nullableInt == 100) { regularInt = nullableInt.Value; } 

There’s also this case:

int? nullableInt = null; int regularInt; if (nullableInt < 100) { regularInt = nullableInt.Value; } 

nullableInt < 100 will evaluate to true if nullableInt has a value, and that value is less than 100. It will however evaluate to false if nullableInt is null. Which one could argue is correct, as nullableInt isn’t a number lower than 100, it’s null (which isn’t a number at all).

I hope you found this interesting, or at least helpful.

Happy coding!