C# Nullable Types (How It Works For Developers)

Declaring Nullable Types

To declare a nullable type in C#, you use the following syntax:

// Declare a nullable integer
int? nullableInt = null;

// Declare a nullable integer
int? nullableInt = null;

Here, int? is shorthand for Nullable<int>. The nullableInt variable can hold either an int value or null.

Checking for null

To check if a nullable type variable has a value or not, you can use the HasValue property or compare the variable directly with null, as shown below:

if (nullableInt.HasValue)
{
    // If nullableInt has a value, print it
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    // If nullableInt does not have a value, print a message
    Console.WriteLine("No value assigned.");
}

if (nullableInt.HasValue)
{
    // If nullableInt has a value, print it
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    // If nullableInt does not have a value, print a message
    Console.WriteLine("No value assigned.");
}

Alternatively, you can use the null coalescing operator (??) to provide a default value when the nullable type is null:

// Assign 0 if nullableInt is null
int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

// Assign 0 if nullableInt is null
int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

If nullableInt is null, result will be assigned the default value of 0.

Nullable Value Types

A nullable value type allows a value type to take a null value. To declare a nullable value type, append a question mark ? to the data type:

// Declare a nullable double
double? nullableDouble = null;

// Declare a nullable double
double? nullableDouble = null;

In this example, nullableDouble can hold a double value or null.

Nullable Reference Types

Nullable reference types were introduced in C# 8.0. You can enable nullable reference types at the project level or by adding the #nullable enable directive at the beginning of your code file. With nullable reference types enabled, reference types must be explicitly marked as nullable using ?, helping to avoid potential runtime exceptions caused by null references.

#nullable enable
// Declare a nullable string
string? nullableString = null;

#nullable enable
// Declare a nullable string
string? nullableString = null;

Here, nullableString is allowed to be null. If you declare a non-nullable reference type without the ?, the compiler will produce warnings if it detects potential null assignments.

Enabling Nullable Reference Types

To enable nullable reference types globally in a project, add the following line to your .csproj file:

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

Once enabled, the compiler will treat reference types as non-nullable by default. This feature is especially handy to catch null reference issues at compile time rather than at runtime.

Example 1: Nullable Type with Value Types

In this example, we’ll use a nullable type with int:

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        // Use null coalescing operator to assign a default value
        int b = nullableInt ?? 10;
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            // nullableInt has a value
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            // nullableInt is null
            Console.WriteLine("nullableInt is null");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        // Use null coalescing operator to assign a default value
        int b = nullableInt ?? 10;
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            // nullableInt has a value
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            // nullableInt is null
            Console.WriteLine("nullableInt is null");
        }
    }
}

Here, nullableInt is a nullable type variable of int. If nullableInt is null, b gets the value 10 due to the null coalescing operator. Otherwise, b takes the value of nullableInt.

Example 2: Nullable Reference Types

Now, let’s see how nullable reference types work:

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        // Use null coalescing operator to provide a default value for length
        Console.WriteLine(nullableString?.Length ?? 0);
        Console.WriteLine(nonNullableString.Length);
    }
}

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        // Use null coalescing operator to provide a default value for length
        Console.WriteLine(nullableString?.Length ?? 0);
        Console.WriteLine(nonNullableString.Length);
    }
}

In the code above, nullableString can be null, and the null coalescing operator ensures that if it is null, the length of the string defaults to 0.

Example 3: Nested Nullable Types

C# allows you to declare nested nullable types. For example:

// Redundant, but syntactically valid
int? nestedNullableInt = null;

// Redundant, but syntactically valid
int? nestedNullableInt = null;

While nested nullable types may seem redundant, they are syntactically valid in C#. However, in practice, nested nullable types don't provide any additional functionality and are rarely used.