The nullable reference types, introduced in C# 8.0, are a powerful feature designed to improve the safety and reliability of your code by helping you avoid null reference exceptions. This feature allows developers to explicitly specify whether a reference type might be null, which helps to catch potential problems at compile time rather than runtime.

What Are Nullable Reference Types?

In traditional C#, reference types (like string, object, or List<T>) can be null by default, which means assigning null to any reference type is allowed. This can lead to one of the most common bugs in programming: null reference exceptions, which occur when you try to access a member of a null object.

Enable nullable reference Type

By default, nullable reference types are disabled in the old project. To enable them you can turn on this feature in your project's .csproj file or on individual files by using some instructions.

To enable it globally for the entire project, add the following to the .csproj file:

csharp
📄
<Nullable>enable</Nullable>

Or, at the top of a C# file:

csharp
📄
#nullable enable

How Nullable Reference Types Work

When nullable reference types are enabled, C# distinguishes between two types of reference variables:

1. Non-nullable reference types: These cannot be null. For example, a string name assumes the name will always hold a valid string and not null.
2. Nullable reference types: These are explicitly marked with a ? to indicate they may be null. For example, the string? name means a name can either hold a string or be null.

Example

In this example, the name is a non-nullable string, meaning it is assumed to never be null, while nullableName is a nullable string (string?), which allows it to hold a null value.

csharp
📄
using System;
class Program
{
    static void Main()
    {
        #nullable enable
        string name = "John"; 
        string? nullableName = null;

        // Safe, name is not null
        Console.WriteLine(name.Length);

        // Safe, nullableName could be null, so use null-check or null-conditional operator
        Console.WriteLine(nullableName?.Length); 
    }
}

Working with Nullable Reference Types

Nullable reference types come with several tools and patterns that make it easier to work with potentially null values.

Null-Conditional Operator (?.)

The null-conditional operator (?.) allows you to safely access members of a nullable type, returning null if the reference is null:

csharp
📄
string? nullableName = null;
// No exception, returns null
int? length = nullableName?.Length; 

Null-Coalescing Operator (??)

The null-coalescing operator (??) lets you provide a default value if the nullable reference is null:

csharp
📄
string? nullableName = null;
// Returns "Default Name"
string name = nullableName ?? "Default Name";

Null Forgiving Operator (!)

The null-forgiving operator (!) is used to tell the compiler that you know a nullable reference is not null, even if it thinks otherwise:

csharp
📄
string? nullableName = "Hello";
// Suppresses the warning
Console.WriteLine(nullableName!.Length);

Use the null-forgiving operator with caution, as incorrect functionality can cause null-reference exceptions at runtime.

In summary, nullable reference types in C# are a valuable tool that helps avoid null reference exceptions by providing explicit handling of nullable values. By enabling nullable reference types, you can make your code safer, more reliable, and easier to maintain. This is a feature that can significantly increase the quality of the code, especially when working with large projects or complex data systems.