How to check for null in C#

string? name = null;

// The modern checks (C# 7 and C# 9)
if (name is null) Console.WriteLine("is null");
if (name is not null) Console.WriteLine("is not null");

// == null gives the same answer for ordinary types
Console.WriteLine(name == null);

// The difference: == can be overloaded, is null can't
var placeholder = new Widget("placeholder");
Console.WriteLine($"== null:         {placeholder == null}");
Console.WriteLine($"is null:         {placeholder is null}");
Console.WriteLine($"ReferenceEquals: {ReferenceEquals(placeholder, null)}");

// is { } tests for "not null" and gives you a non-null variable
object? boxed = 42;
if (boxed is int n) Console.WriteLine($"an int: {n + 1}");
string? input = "hello";
if (input is { } text) Console.WriteLine($"{text.Length} chars");
if (input is { Length: > 3 }) Console.WriteLine("not null and longer than 3");

class Widget(string label)
{
    public string Label { get; } = label;

    // A "fake null": this type says a placeholder equals null
    public static bool operator ==(Widget? a, Widget? b) =>
        (a?.Label ?? "placeholder") == (b?.Label ?? "placeholder");
    public static bool operator !=(Widget? a, Widget? b) => !(a == b);
    public override bool Equals(object? obj) => obj is Widget w && this == w;
    public override int GetHashCode() => Label.GetHashCode();
}

string? nickname = null;
string? fullName = "Ada Lovelace";

// a ?? b: a when it isn't null, otherwise b
Console.WriteLine(nickname ?? "Guest");
Console.WriteLine(fullName ?? "Guest");

// Chain it: the first non-null value wins
string? fromArgs = null, fromEnv = null, fromConfig = "config.json";
Console.WriteLine(fromArgs ?? fromEnv ?? fromConfig ?? "defaults");

// ??= assigns only when the variable is null (C# 8)
List<string>? log = null;
log ??= [];
log.Add("first");
log ??= ["never used"];
Console.WriteLine($"{log.Count}: {string.Join(", ", log)}");

// ?? only checks null: an empty string is a value
string? blank = "";
Console.WriteLine($"[{blank ?? "Guest"}]");
Console.WriteLine($"[{(string.IsNullOrWhiteSpace(blank) ? "Guest" : blank)}]");

// The right side can be a throw expression (C# 7)
string Require(string? value) =>
    value ?? throw new ArgumentNullException(nameof(value));

try
{
    Require(null);
}
catch (ArgumentNullException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

Customer? withAddress = new("Ada", new Address("London"));
Customer? noAddress = new("Grace", null);
Customer? nobody = null;

// ?. stops at the first null and the whole chain becomes null
Console.WriteLine(withAddress?.Address?.City ?? "(no city)");
Console.WriteLine(noAddress?.Address?.City ?? "(no city)");
Console.WriteLine(nobody?.Address?.City ?? "(no city)");

// A value-type member comes back as a nullable: int? here, not int
int? length = nobody?.Name.Length;
Console.WriteLine(length is null);
Console.WriteLine(noAddress?.Name.Length ?? 0);

// Methods too: the call is skipped, arguments and all
Console.WriteLine(nobody?.Greet(Loud("hi")) ?? "(skipped)");
Console.WriteLine(withAddress?.Greet(Loud("hi")) ?? "(skipped)");

// ?[] does the same for indexers
string[]? tags = null;
Console.WriteLine(tags?[0] ?? "(no tags)");

// ?.Invoke calls a delegate only if something is attached
Action<string>? onSaved = null;
onSaved?.Invoke("nothing happens");
onSaved += msg => Console.WriteLine($"saved: {msg}");
onSaved?.Invoke("report.pdf");

static string Loud(string s)
{
    Console.WriteLine("evaluating argument");
    return s.ToUpper();
}

record Address(string City);

record Customer(string Name, Address? Address)
{
    public string Greet(string word) => $"{word}, {Name}";
}

int? stock = null;          // shorthand for Nullable<int>
int? price = 25;

Console.WriteLine(stock.HasValue);
Console.WriteLine(price.HasValue);
Console.WriteLine(stock is null);

// int? to int: pick what null should become
int a = stock ?? 0;
int b = stock.GetValueOrDefault();
int c = stock.GetValueOrDefault(-1);
int d = price.Value;        // safe only after a check
Console.WriteLine($"{a} {b} {c} {d}");

// Pattern matching checks and unwraps in one step
if (price is int p) Console.WriteLine($"price is {p}");

// .Value or a cast on a null throws
try
{
    int bad = (int)stock;
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// Arithmetic with null gives null ("lifted" operators)
int? total = price + stock;
Console.WriteLine(total is null);
Console.WriteLine($"[{total}]");

// Comparisons with null are false both ways, but == null works
Console.WriteLine(stock > 0);
Console.WriteLine(stock <= 0);
Console.WriteLine(stock == null);

// Parsing: int.TryParse into a nullable
int? ParseOrNull(string s) => int.TryParse(s, out int n) ? n : null;
Console.WriteLine(ParseOrNull("42") ?? -1);
Console.WriteLine(ParseOrNull("forty-two") ?? -1);

string[] names = new string[3];               // elements start out null
List<string> users = ["ada", "grace"];
object boxed = 42;

// Four common ways to end up calling a member on null
TryRun("array slot", () => names[0].ToUpper());
TryRun("FirstOrDefault", () => users.FirstOrDefault(u => u.StartsWith('z')).Length);
TryRun("'as' cast", () => (boxed as string).Trim());
TryRun("field never set", () => new Order().Notes.Count);

// Fix: handle the null where it can appear
string? match = users.FirstOrDefault(u => u.StartsWith('z'));
Console.WriteLine(match?.Length ?? 0);
Console.WriteLine(boxed is string s ? s.Trim() : "not a string");
Console.WriteLine(new SafeOrder().Notes.Count);

// Fix: reject null at the boundary with a clear message (.NET 6+)
try
{
    Greet(null);
}
catch (ArgumentNullException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

static void Greet(string name)
{
    ArgumentNullException.ThrowIfNull(name);
    Console.WriteLine($"Hello, {name}");
}

static void TryRun(string label, Func<object> action)
{
    try
    {
        action();
    }
    catch (NullReferenceException e)
    {
        Console.WriteLine($"{label}: {e.Message}");
    }
}

class Order
{
    public List<string> Notes;                // never assigned, so null
}

class SafeOrder
{
    public List<string> Notes = [];           // initialized: never null
}