How to check if a nullable bool is true in C#

The bool? type (nullable boolean) is one such type that can hold three possible values: true, false, or null.

1. You Can’t Use bool? Exactly Like bool

A bool? (nullable bool) can be true, false, or null. However, many operations you can perform on a regular bool will not work the same way with a nullable bool. Let's go over some common scenarios where using bool? like a regular bool can result in compiler errors or runtime exceptions.

For example, Operator ‘&&’ Cannot Be Applied to Operands of Type ‘bool?’ and ‘bool’

When combining a nullable bool (bool?) with a regular boolean (bool) in a logical expression, the C# compiler will not know how to handle the mismatch. Specifically, you might encounter this error:

Operator ‘&&’ cannot be applied to operands of type ‘bool?’ and ‘bool’

This happens because a bool? can be null, and the && operator doesn't know how to handle a null value in this context.

bool? nullableBool = null;
bool regularBool = true;

if (nullableBool && regularBool)  // Compiler error!
{
    // Do something
}

You must explicitly check if the nullable boolean is true before using it in a logical expression. This ensures the operation handles the nullable nature of bool? correctly.

bool? nullableBool = null;
bool regularBool = true;

if (nullableBool == true && regularBool)  // Works fine!
{
    // Do something
}

2. Cannot Implicitly Convert Type ‘bool?’ to ‘bool’

If you try to use a bool? directly in a condition (like an if statement) without explicitly checking its value, you will encounter the following error:

Cannot implicitly convert type ‘bool?’ to ‘bool’. An explicit conversion exists (are you missing a cast?)

This occurs because the compiler can't automatically treat a bool? as a regular bool since bool? could be null, which is not a valid value for a bool.

bool? nullableBool = null;

if (nullableBool)  // Compiler error!
{
    // Do something
}

Instead of using the nullable boolean directly, compare it explicitly to true or false:

bool? nullableBool = null;

if (nullableBool == true)  // Works fine!
{
    // Do something
}

This ensures that the if statement only evaluates the condition when the nullable boolean has a concrete value (true or false).

3. Errors When Using Null-Conditional (?.) with Booleans

The null-conditional operator (?.) is often used to avoid null reference exceptions when calling methods or accessing properties on objects that might be null. However, when used with a bool?, it can introduce unexpected behavior.

For example, if you try to chain method calls with a nullable boolean, the result will be treated as a nullable boolean (bool?) instead of a regular boolean (bool). This can cause the compiler to throw an error when you use the result in a conditional statement.

Person person = new Person();

if (person.Pets?.Any())  // Compiler error!
{
    // Do something
}

Here, Any() returns a bool?, but the null-conditional operator makes the result nullable. Trying to use this directly in an if statement leads to the error:

Cannot implicitly convert type ‘bool?’ to ‘bool’. An explicit conversion exists (are you missing a cast?)

To fix this, explicitly compare the result to true:

Person person = new Person();

if (person.Pets?.Any() == true)  // Works fine!
{
    // Do something
}

This way, you are explicitly checking if the result of Any() is true, handling the nullable return type correctly.

4. InvalidOperationException: ‘Nullable Object Must Have a Value.’

One of the most common runtime exceptions you’ll encounter when working with nullable types is the InvalidOperationException thrown when you attempt to access the .Value property on a nullable type that is null.

For instance, if you try to access the .Value property on a bool? that is null, you’ll get the following exception:

System.InvalidOperationException: ‘Nullable object must have a value.’

bool? nullableBool = null;

if (nullableBool.Value)  // Runtime exception!
{
    // Do something
}

Instead of accessing the .Value property directly, always compare the nullable boolean to true or false:

bool? nullableBool = null;

if (nullableBool == true)  // Works fine!
{
    // Do something
}

This prevents you from attempting to dereference a nullable boolean that is null, avoiding the runtime exception.