Nullable Types and Null Safety

int? maybe = null;

Console.WriteLine(maybe.HasValue);                // False
Console.WriteLine(maybe.GetValueOrDefault());     // 0
Console.WriteLine(maybe.GetValueOrDefault(-1));   // -1
Console.WriteLine(maybe ?? -1);                   // -1

maybe = 42;
Console.WriteLine(maybe.HasValue);                // True
Console.WriteLine(maybe.Value);                   // 42

int? none = null;
try
{
    Console.WriteLine(none.Value);                // throws InvalidOperationException
}
catch (InvalidOperationException)
{
    Console.WriteLine("Value on a null nullable throws");
}

// Pattern matching is the clean way to unwrap.
if (maybe is int value)
{
    Console.WriteLine(value * 2);                 // 84
}

#nullable enable

public sealed class Customer2
{
    public required string Name { get; init; }      // must not be null
    public string? MiddleName { get; init; }        // may be null

    public string FullName =>
        MiddleName is null ? Name : $"{Name} {MiddleName}";
}

public static class NrtBasics
{
    public static int LengthOf(string? maybe)
    {
        // Console.WriteLine(maybe.Length);   // warning CS8602: possible null dereference

        if (maybe is null)
        {
            return 0;
        }

        return maybe.Length;        // here the compiler knows it is not null
    }

    public static string Normalise(string? input) => input?.Trim() ?? string.Empty;
}

<PropertyGroup>
  <Nullable>enable</Nullable>
  <!-- Optional, and recommended once clean: make the warnings errors. -->
  <WarningsAsErrors>nullable</WarningsAsErrors>
</PropertyGroup>

#nullable enable

public static class FlowAnalysis
{
    public static void Demo(string? input)
    {
        // Each of these narrows the state to not-null in the body:
        if (input != null) { Console.WriteLine(input.Length); }
        if (input is not null) { Console.WriteLine(input.Length); }
        if (input is string s) { Console.WriteLine(s.Length); }
        if (!string.IsNullOrEmpty(input)) { Console.WriteLine(input.Length); }

        // ?? and ?. participate too.
        Console.WriteLine((input ?? "").Length);
        Console.WriteLine(input?.Length ?? 0);

        // An early return narrows for the rest of the method.
        if (input is null)
        {
            return;
        }

        Console.WriteLine(input.Length);        // not-null from here on
    }
}

#nullable enable

public static class NullabilityContracts
{
    // The out parameter is meaningful only when the method returns true.
    public static bool TryFind(IEnumerable<string> source, string prefix,
        [NotNullWhen(true)] out string? found)
    {
        foreach (string item in source)
        {
            if (item.StartsWith(prefix, StringComparison.Ordinal))
            {
                found = item;
                return true;
            }
        }

        found = null;
        return false;
    }

    // null in, null out; non-null in, non-null out.
    [return: NotNullIfNotNull(nameof(input))]
    public static string? Normalise(string? input) => input?.Trim();

    // Never returns -- the compiler stops analysing the code after a call.
    [DoesNotReturn]
    public static void Fail(string message) => throw new InvalidOperationException(message);

    public static void Demo(IEnumerable<string> source)
    {
        if (TryFind(source, "a", out string? match))
        {
            Console.WriteLine(match.Length);       // no warning -- NotNullWhen(true)
        }

        string normalised = Normalise("  x  ");    // no warning -- NotNullIfNotNull
        Console.WriteLine(normalised.Length);
    }
}

public sealed class LazyInitialised
{
    private string? _value;

    // Tells the compiler _value is not null once Initialize has returned.
    [MemberNotNull(nameof(_value))]
    public void Initialize() => _value = "ready";

    [MemberNotNullWhen(true, nameof(_value))]
    public bool IsReady => _value is not null;

    public int Use()
    {
        Initialize();
        return _value.Length;          // no warning
    }

    public int UseIfReady() => IsReady ? _value.Length : 0;   // no warning
}

#nullable enable

public static class Guarding
{
    public static void Configure(string? host, int port, IReadOnlyList<string>? tags)
    {
        // The modern BCL guards -- each uses CallerArgumentExpression for the message.
        ArgumentNullException.ThrowIfNull(host);
        ArgumentException.ThrowIfNullOrWhiteSpace(host);
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(port);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(port, 65535);

        // After the guard the compiler treats `host` as not-null.
        Console.WriteLine(host.ToUpperInvariant());
        Console.WriteLine(tags?.Count ?? 0);
    }
}

#nullable enable

public sealed class Options2
{
    // Without `required`, this would warn CS8618: non-nullable property uninitialised.
    public required string ConnectionString { get; init; }
    public required Uri Endpoint { get; init; }

    public int Retries { get; init; } = 3;
    public string? Region { get; init; }
}

public static class RequiredDemo2
{
    public static void Run()
    {
        var options = new Options2
        {
            ConnectionString = "Host=localhost",
            Endpoint = new Uri("https://example.com"),
        };

        Console.WriteLine($"{options.ConnectionString} {options.Retries} {options.Region ?? "-"}");
    }
}