null and nullable types

Handle missing values safely with nullable types, ?., ?? and the compiler's null-safety warnings.

The billion-dollar mistake

A reference-type variable can contain null — a reference to nothing. Using a member of null crashes:

string? name = null;
Console.WriteLine(name.Length);   // 💥 NullReferenceException

NullReferenceException is the most common exception in .NET. The inventor of null references, Tony Hoare, called them his "billion-dollar mistake". C# gives you several tools to stay safe.

Nullable value types: int?

Value types can't be null — an int always holds a number. When "no value" is meaningful (a score not entered yet, an optional age), use a nullable value type by adding ?:

int? age = null;
 
if (age.HasValue)
    Console.WriteLine($"Age: {age.Value}");
else
    Console.WriteLine("Age unknown");
 
age = 36;
int realAge = age ?? 0;     // fall back to 0 if null

int? is shorthand for Nullable<int>.

Nullable reference types

Modern projects enable nullable reference types (<Nullable>enable</Nullable> in the .csproj, on by default in new projects and in this course's editor). The compiler then tracks which references may be null:

string means "should never be null".
string? means "might be null — check before use".

string? GetMiddleName() => null;
 
string? middle = GetMiddleName();
Console.WriteLine(middle.Length);
//                ~~~~~~ warning CS8602: Dereference of a possibly null reference.

These are warnings, not errors: the program still compiles. But each one marks a potential crash — treat them seriously.

Note

Nullable reference types are purely a compile-time feature. At run time string? and string are the same type; nothing stops a null from arriving from old code. The annotations help the compiler help you.

Checking for null

if (middle is not null)
{
    Console.WriteLine(middle.Length);   // no warning: the compiler knows it's not null here
}
 
if (string.IsNullOrEmpty(middle)) { ... }        // null or ""
if (string.IsNullOrWhiteSpace(middle)) { ... }   // null, "" or only spaces

Null operators

Operator	Name	Meaning
`a?.B`	null-conditional	`null` if `a` is null, otherwise `a.B`
`a?[i]`	null-conditional index	`null` if `a` is null, otherwise `a[i]`
`a ?? b`	null-coalescing	`a` if not null, otherwise `b`
`a ??= b`	null-coalescing assignment	assign `b` to `a` only if `a` is null
`a!`	null-forgiving	"trust me, it's not null" — silences the warning

They combine beautifully:

string city = order?.Customer?.Address?.City ?? "Unknown";
int length = name?.Length ?? 0;
 
cache ??= LoadCache();        // lazy initialization

Use ! sparingly

name!.Length removes the warning but not the danger. Only use ! when you know something the compiler can't — and prefer restructuring the code so it can tell.

Designing with null

Make values non-nullable by default; add ? only where "missing" is a real possibility.
Initialize properties: public string Name { get; set; } = ""; or make them required:

class User
{
    public required string Email { get; init; }   // must be set in the object initializer
    public string? Nickname { get; init; }         // genuinely optional
}
 
var u = new User { Email = "ada@example.com" };

Return an empty collection, not null, when there's nothing to return.

Try it

Read the warnings under the output, then fix them with ?. and ??:

Program.csCtrl + Enter to run

Loading editor…

C# runtime not loaded

Key takeaways

Dereferencing null throws NullReferenceException.
int? lets value types be null; check .HasValue or use ??.
With nullable reference types, string? may be null and the compiler warns about unsafe use.
?., ?? and ??= handle missing values concisely; avoid overusing !.

You will learn