Nullability attributes, guards and migration

using System.Diagnostics.CodeAnalysis;

// Two Try methods that do the same work. Only TryFindStation tells the compiler what true means.
var timetable = new Timetable();

if (timetable.TryFind("NDLS", out Station? first))
{
    Console.WriteLine(first.Name);
}

if (timetable.TryFindStation("SBC", out Station? second))
{
    Console.WriteLine(second.Name);
}

if (!timetable.TryFindStation("XYZ", out Station? third))
{
    Console.WriteLine($"XYZ: not found, station is null: {third is null}");
}

class Station
{
    public Station(string name) => Name = name;

    public string Name { get; }
}

class Timetable
{
    private readonly Dictionary<string, Station> _byCode = new()
    {
        ["NDLS"] = new Station("New Delhi"),
        ["SBC"] = new Station("KSR Bengaluru"),
    };

    public bool TryFind(string code, out Station? station) => _byCode.TryGetValue(code, out station);

    public bool TryFindStation(string code, [NotNullWhen(true)] out Station? station) =>
        _byCode.TryGetValue(code, out station);
}

from session import run

# stations calls two Try methods that differ only in [NotNullWhen(true)]. It is built once and run once.
run("""
cd stations
dotnet build -v q
dotnet bin/Debug/net10.0/App.dll
""")

$ cd stations
$ dotnet build -v q
stations/Program.cs(8,23): warning CS8602: Dereference of a possibly null reference. [stations/App.csproj]

Build succeeded.

stations/Program.cs(8,23): warning CS8602: Dereference of a possibly null reference. [stations/App.csproj]
    1 Warning(s)
    0 Error(s)

Time Elapsed …
$ dotnet bin/Debug/net10.0/App.dll
New Delhi
KSR Bengaluru
XYZ: not found, station is null: True

// Guard clauses at a public method: each helper names the argument it refused.
var shipping = new Shipping();
var asha = new Customer("Asha Rao");

Report("a null order", () => shipping.Label(null!, "Pune"));
Report("an order with no customer", () => shipping.Label(new Order("A-101", null), "Pune"));
Report("an empty city", () => shipping.Label(new Order("A-102", asha), ""));
Report("a blank city", () => shipping.Label(new Order("A-103", asha), "   "));
Report("a complete order", () => shipping.Label(new Order("A-104", asha), "Pune"));

static void Report(string what, Func<string> label)
{
    try
    {
        Console.WriteLine($"{what}: {label()}");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine($"{what}: {e.GetType().Name}: {e.Message}");
    }
}

class Customer
{
    public Customer(string name) => Name = name;

    public string Name { get; }
}

class Order
{
    public Order(string id, Customer? customer)
    {
        Id = id;
        Customer = customer;
    }

    public string Id { get; }

    public Customer? Customer { get; }
}

class Shipping
{
    public string Label(Order order, string city)
    {
        ArgumentNullException.ThrowIfNull(order);
        ArgumentNullException.ThrowIfNull(order.Customer);
        ArgumentException.ThrowIfNullOrWhiteSpace(city);
        return $"{order.Id} for {order.Customer.Name}, {city}";
    }
}

a null order: ArgumentNullException: Value cannot be null. (Parameter 'order')
an order with no customer: ArgumentNullException: Value cannot be null. (Parameter 'order.Customer')
an empty city: ArgumentException: The value cannot be an empty string or composed entirely of whitespace. (Parameter 'city')
a blank city: ArgumentException: The value cannot be an empty string or composed entirely of whitespace. (Parameter 'city')
a complete order: A-104 for Asha Rao, Pune

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <WarningsAsErrors>nullable</WarningsAsErrors>
  </PropertyGroup>

</Project>

using System.Diagnostics.CodeAnalysis;

// Practice: annotate NameCache and add guard clauses, without changing what it does, until the project builds
// with nullable warnings as errors and Program.cs prints "6 of 6 checks pass".
public class NameCache
{
    private Dictionary<string, string> _names;

    public NameCache() => Initialize();

    public NameCache(Dictionary<string, string> seed)
    {
        Initialize();
        foreach (var (code, name) in seed)
        {
            _names[code] = name;
        }
    }

    public int Hits { get; private set; }

    public bool TryGet(string code, out string? name) => _names.TryGetValue(code, out name);

    public string GetOrAdd(string code, Func<string, string> load)
    {
        if (_names.TryGetValue(code, out string? name))
        {
            Hits++;
            return name;
        }

        name = load(code);
        _names[code] = name;
        return name;
    }

    private void Initialize()
    {
        _names = [];
        Hits = 0;
    }
}

// The call sites and checks of the practice. Leave this file as it is.
var cache = new NameCache(new() { ["P-1"] = "Masala tea", ["P-2"] = "Filter coffee" });

(string Check, Func<string> Run, string Expected)[] checks =
[
    ("TryGet finds P-1", () => cache.TryGet("P-1", out string? name) ? $"{name.Length} characters" : "missing", "10 characters"),
    ("TryGet misses P-9", () => cache.TryGet("P-9", out string? name) ? name : "missing", "missing"),
    ("GetOrAdd loads P-3 once", () => $"{cache.GetOrAdd("P-3", Load)} / {cache.GetOrAdd("P-3", Load)} / hits {cache.Hits}", "Lemon soda / Lemon soda / hits 1"),
    ("a null code", () => cache.GetOrAdd(null!, Load), "throws ArgumentNullException for code"),
    ("a blank code", () => cache.GetOrAdd("  ", Load), "throws ArgumentException for code"),
    ("a null loader", () => cache.GetOrAdd("P-4", null!), "throws ArgumentNullException for load"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (ArgumentException e)
    {
        got = $"throws {e.GetType().Name} for {e.ParamName}";
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, {got} instead of {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

static string Load(string code) => code == "P-3" ? "Lemon soda" : "Unknown";

from session import run

# The practice project as it starts: built with nullable warnings as errors. Its errors are sorted, each shown once,
# because the compiler can report them in a different order from one build to the next.
run("""
cd cache
dotnet build -v q | grep -E "error CS|Error\\(s\\)" | sort -u
""")

$ cd cache
$ dotnet build -v q | grep -E "error CS|Error\(s\)" | sort -u
    5 Error(s)
cache/NameCache.cs(11,12): error CS8618: Non-nullable field '_names' must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring the field as nullable. [cache/App.csproj]
cache/NameCache.cs(16,13): error CS8602: Dereference of a possibly null reference. [cache/App.csproj]
cache/NameCache.cs(9,12): error CS8618: Non-nullable field '_names' must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring the field as nullable. [cache/App.csproj]
cache/Program.cs(6,75): error CS8602: Dereference of a possibly null reference. [cache/App.csproj]
cache/Program.cs(7,33): error CS8603: Possible null reference return. [cache/App.csproj]