Nullable Types

Nullable Types in C#: The Gift Box Story 🎁

The Big Idea

Imagine you have a gift box. Sometimes the box has a present inside. Sometimes it’s empty. Nullable types in C# are like these gift boxes — they can hold a value OR be empty (null).

🎁 What Are Nullable Value Types?

The Problem: Regular Boxes Must Have Something

In C#, regular value types like int, bool, and double are like boxes that must always contain something.

int age = 25;        // ✅ Has a value
int mystery;         // ❌ Error! Must give it a value

But what if you don’t know someone’s age yet? What if the box should be… empty?

The Solution: The Magic “?” Symbol

Add a ? after the type name. Now your box can be empty!

int? age = 25;       // ✅ Has a value
int? mystery = null; // ✅ Empty box - totally fine!

Think of it like this:

• int = A box that MUST have a number
• int? = A box that MIGHT have a number (or be empty)

🔍 Checking If Your Box Is Empty

Before opening a gift, you want to know if there’s something inside!

Method 1: HasValue

int? coins = 50;

if (coins.HasValue)
{
    Console.WriteLine(quot;You have {coins.Value} coins!");
}
else
{
    Console.WriteLine("Your coin purse is empty.");
}

Method 2: The Simple Check

int? score = null;

if (score != null)
{
    Console.WriteLine(quot;Score: {score}");
}

🛡️ Default Values: The Safety Net

What if the box is empty but you need a number anyway? Use the ?? operator!

int? temperature = null;
int safeTemp = temperature ?? 20;

Console.WriteLine(safeTemp); // Prints: 20

Translation: “Give me the temperature. If it’s empty, give me 20 instead.”

📦 Nullable Reference Types: A Newer Story

Starting with C# 8, we got a new superpower: nullable reference types.

The Old Problem

Before, things like string could always be null. This caused crashes!

string name = null;          // Old C#: No warning!
Console.WriteLine(name.Length); // 💥 CRASH!

The New Way

Now C# warns you about potential null problems:

string name = null;   // ⚠️ Warning! You said this won't be null
string? maybe = null; // ✅ This is allowed - you marked it nullable

🎯 Quick Comparison

graph TD
    A["Value Types"] --> B["int, bool, double"]
    A --> C["Cannot be null by default"]
    A --> D["Add ? to make nullable"]

    E["Reference Types in C# 8+"] --> F["string, object, arrays"]
    E --> G["Non-null by default"]
    E --> H["Add ? to allow null"]

🧙‍♂️ The Null-Forgiving Operator: “Trust Me!”

Sometimes you KNOW a value isn’t null, but C# doesn’t believe you. Use ! to say “I promise it’s not null!”

string? possiblyNull = GetName();

// You checked somewhere and KNOW it's not null
string definitelyNotNull = possiblyNull!;

⚠️ Use carefully! If you’re wrong, your app crashes.

🎮 Real World Examples

Example 1: User Profile

public class User
{
    public string Name { get; set; }      // Required!
    public string? Nickname { get; set; } // Optional
    public int? Age { get; set; }         // Optional
}

var user = new User
{
    Name = "Alex",
    Nickname = null,  // No nickname yet
    Age = null        // Didn't tell us
};

Example 2: Finding Things

int? foundIndex = FindItem("apple");

if (foundIndex.HasValue)
{
    Console.WriteLine(quot;Found at position {foundIndex}");
}
else
{
    Console.WriteLine("Not found!");
}

🌟 Golden Rules

1. Use ? when something might be empty
2. Always check for null before using the value
3. Use ?? to provide safe default values
4. Enable nullable reference types in new projects

🎁 Summary: The Gift Box Rules

🚀 You Did It!

You now understand nullable types! Think of them as gift boxes:

• Value types with ? = boxes that can be empty
• Reference types with ? = you’re allowed to leave them empty
• Always check before opening to avoid surprises!

Go forth and write safer C# code! 🎉