📝 Lesson 3.3: Nullable Reference Types

The Null Problem

null means "no value — this reference points to nothing." Trying to use a null reference (call a method, read a property) throws a NullReferenceException and crashes your program. You met this exception in Lesson 1.1.

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

The core idea: let you declare your intent — "this can be null" or "this must never be null" — and have the compiler check that you honor it.

Nullable Value Types (Recap)

Value types like int and bool normally can't be null. But sometimes you need "an int, or no value at all" — say, an optional age. Add ? to make a nullable value type:

int? maybeAge = null;      // an int that can also be null
maybeAge = 30;

if (maybeAge.HasValue)
{
    Console.WriteLine(maybeAge.Value);   // 30
}

int definiteAge = maybeAge ?? 0;   // use 0 if null (?? explained below)

This is the generic Nullable<T> from Lesson 1.2, with ? as convenient shorthand. Nullable reference types use the same ? symbol — but they work a little differently, as we'll see.

Nullable Reference Types

Reference types (like string and your own classes) have always been able to hold null. The nullable reference types feature doesn't change that at runtime — instead, it adds compile-time analysis. In a nullable-aware project, you declare which references are allowed to be null:

string name = "Ada";      // non-nullable
string? nickname = null;   // nullable — this is fine

Console.WriteLine(name.Length);       // OK — compiler knows it's not null
Console.WriteLine(nickname.Length);   // ⚠️ Warning — nickname might be null!

The compiler traces your code. Once you've checked for null, the warning goes away inside that block — it understands the guard:

if (nickname != null)
{
    Console.WriteLine(nickname.Length);   // OK here — you proved it's not null
}

Null-Safe Operators

C# has three concise operators that make working with possibly-null values painless.

Null-conditional ?.

The ?. operator (you saw it raising events in Lesson 2.2) accesses a member only if the left side isn't null; otherwise the whole expression is null — no crash:

string? name = null;

int? length = name?.Length;      // null (not a crash) because name is null
Console.WriteLine(length);       // (prints nothing / empty)

name = "Ada";
Console.WriteLine(name?.Length); // 3

Null-coalescing ??

The ?? operator supplies a fallback value when the left side is null:

string? input = null;
string display = input ?? "(no name)";   // use the fallback if input is null
Console.WriteLine(display);              // (no name)

// Combine ?. and ?? for a safe default:
int length = name?.Length ?? 0;          // 0 if name is null

Null-coalescing assignment ??=

The ??= operator assigns a value only if the variable is currently null — handy for lazy defaults:

string? config = null;
config ??= "default-settings";   // assigns because config was null
config ??= "other";              // does nothing — config is no longer null
Console.WriteLine(config);       // default-settings

The Null-Forgiving Operator

Occasionally you know a value isn't null even though the compiler can't prove it. The null-forgiving operator ! tells the compiler "trust me, this isn't null here," suppressing the warning:

string? GetName() => "Ada";   // always returns a value in practice

string name = GetName()!;      // '!' — I promise this isn't null
Console.WriteLine(name.Length);

Practical Patterns

A few habits make nullable-aware code pleasant to write:

void Greet(string? name)
{
    if (name is null)
    {
        Console.WriteLine("Hello, stranger!");
        return;                          // early exit — 'name' is non-null after this
    }
    Console.WriteLine($"Hello, {name}!");   // no warning — guarded above
}

class User
{
    public required string Name { get; set; }   // callers must set it
    public string? Bio { get; set; }            // optional — may be null
}

💡 The mindset shift: Treat every nullable warning as the compiler pointing at a possible future crash. Either prove the value isn't null (a check), provide a fallback (??), or reconsider whether the reference should be nullable at all. This habit eliminates a whole class of bugs.

Exercise & Quiz

Print(new Profile("Ada") { Bio = "Mathematician", Website = "ada.dev" });
Print(new Profile("Grace"));
Print(null);

void Print(Profile? profile)
{
    // TODO: guard against null profile
    // TODO: print Name, Bio ?? "(no bio)", and Website?.Length ?? 0
}

class Profile
{
    public string Name;
    public string? Bio;
    public string? Website;
    public Profile(string name) { Name = name; }
}

Print(new Profile("Ada") { Bio = "Mathematician", Website = "ada.dev" });
Print(new Profile("Grace"));
Print(null);

void Print(Profile? profile)
{
    if (profile is null)
    {
        Console.WriteLine("No profile.");
        return;
    }

    Console.WriteLine($"Name: {profile.Name}");
    Console.WriteLine($"Bio: {profile.Bio ?? "(no bio)"}");
    Console.WriteLine($"Website length: {profile.Website?.Length ?? 0}");
    Console.WriteLine("---");
}

class Profile
{
    public string Name;
    public string? Bio;
    public string? Website;
    public Profile(string name) { Name = name; }
}

Name: Ada
Bio: Mathematician
Website length: 7
---
Name: Grace
Bio: (no bio)
Website length: 0
---
No profile.

Summary

📚 Additional Resources

• Nullable reference types — Microsoft Docs
• ?? and ??= operators — reference
• Null-conditional operators ?. and ?[] — reference

🚀 What's Next?

That completes Module 3 — your C# is now modern, concise, and null-safe! In Module 4, your programs start interacting with the outside world. First up: Lesson 4.1: Working with Files and Streams, where data finally outlives the program run.