Nullable w C#: int?, operator ??, ?. i sprawdzanie null

null oznacza "brak wartości". Typy referencyjne (klasy, stringi, tablice) zawsze mogły go przechowywać. Typy wartościowe (int, decimal, bool, DateTime, struktury) nie mogą, chyba że uczynisz je nullable za pomocą ?. C# daje wtedy mały zestaw operatorów do pracy z wartościami, których może brakować: ??, ??= i ?..

Typy wartościowe nullable: int?

Dodaj ? do typu wartościowego, żeby dopuścić null. int? to skrót od struktury Nullable<int>, która przechowuje wartość i flagę mówiącą, czy ta wartość jest obecna:

using System;

class Program
{
    static void Main()
    {
        int? rating = null;          // e.g. a review with no star rating
        decimal? discount = 5.50m;

        Console.WriteLine(rating.HasValue);
        Console.WriteLine(rating == null);
        Console.WriteLine(discount.HasValue);
        Console.WriteLine(discount.Value);

        Console.WriteLine(rating.GetValueOrDefault());      // 0 when null
        Console.WriteLine(rating.GetValueOrDefault(3));     // your own fallback

        rating = 4;
        if (rating.HasValue)
            Console.WriteLine($"Rated {rating.Value} stars");

        int plain = rating ?? 0;     // back to a non-nullable int
        Console.WriteLine(plain);
    }
}

Wynik:

False
True
True
5.50
0
3
Rated 4 stars
4

Typowe źródła typów wartościowych nullable to opcjonalne pola formularzy, parametry zapytań i kolumny NULL w bazie danych: Order z DateTime? ShippedAt nie został wysłany, dopóki wartość jest null. Alternatywa, czyli magiczna wartość w rodzaju -1 albo DateTime.MinValue, wygląda jak prawdziwe dane i prędzej czy później zostanie tak użyta.

int? konwertuje się na int tylko jawnie, bo konwersja może się nie udać. To prowadzi nas do jedynego wyjątku, który rzucają typy wartościowe nullable.

"Nullable object must have a value"

Odczyt .Value, gdy wartości nie ma, albo rzutowanie int? równego null na int rzuca InvalidOperationException:

using System;

class Program
{
    static int? FindStock(string sku) => sku == "MUG-01" ? 12 : (int?)null;

    static void Main()
    {
        int? stock = FindStock("LAMP-9");

        try
        {
            int n = stock.Value;          // same result with (int)stock
            Console.WriteLine(n);
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine($"{e.GetType().Name}: {e.Message}");
        }

        // Safe alternatives:
        Console.WriteLine(stock ?? 0);
        Console.WriteLine(stock.GetValueOrDefault());
        if (stock is int count) Console.WriteLine(count);
        else Console.WriteLine("not stocked");
    }
}

Wynik:

InvalidOperationException: Nullable object must have a value.
0
0
not stocked

stock is int count to wzorzec: w jednym kroku sprawdza, czy jest wartość, i rozpakowuje ją do count, co czyta się lepiej niż HasValue razem z Value. Więcej form znajdziesz na stronie o dopasowywaniu wzorców.

Arytmetyka i porównania z null

Operatory na typach wartościowych nullable są podniesione (lifted): jeśli którykolwiek operand jest null, wynik jest null. Wyjątkiem są porównania porządkowe (<, >, <=, >=): zwracają false zamiast null. (Drugi wyjątek to bool? z & i |, gdzie null & false daje false.) Na przykład:

using System;

class Program
{
    static void Main()
    {
        int? a = null;
        int? b = 10;

        int? sum = a + b;
        Console.WriteLine(sum == null);
        Console.WriteLine($"[{sum}]");       // null formats as an empty string

        Console.WriteLine(a > 5);
        Console.WriteLine(a <= 5);           // also false: null is not ordered
        Console.WriteLine(a == null);
        Console.WriteLine(b == 10);
    }
}

Wynik:

True
[]
False
False
True
True

Zarówno a > 5, jak i a <= 5 są fałszywe, więc gdy a jest null, !(a > 5) to nie to samo co a <= 5. Kod w rodzaju if (!(age >= 18)) Deny(); traktuje brak wieku jak niepełnoletność, co może, ale nie musi być tym, o co ci chodziło. Najpierw zdecyduj, co ma oznaczać null, zwykle za pomocą ??, a dopiero potem porównuj.

Operator null coalescing ??

a ?? b daje a, gdy a nie jest null, a w przeciwnym razie b. Działa na typach wartościowych nullable i na typach referencyjnych, a łańcuchy obliczane są od lewej do prawej:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var settings = new Dictionary<string, string> { ["theme"] = "dark" };

        string userTheme = null;
        string siteTheme;
        settings.TryGetValue("theme", out siteTheme);
        string fontSize;
        settings.TryGetValue("font-size", out fontSize);

        Console.WriteLine(userTheme ?? siteTheme ?? "light");
        Console.WriteLine(fontSize ?? "16px");

        int? pageSize = null;
        int size = pageSize ?? 20;
        Console.WriteLine(size);

        string nickname = null;
        string display = nickname ?? "Anonymous";
        Console.WriteLine(display.ToUpper());
    }
}

Wynik:

dark
16px
20
ANONYMOUS

Prawa strona jest obliczana tylko wtedy, gdy jest potrzebna, więc cache ?? LoadFromDatabase() nie odpytuje bazy danych, gdy cache ma wartość. ?? przyjmuje też wyrażenie throw, co daje zwięzłe zabezpieczenie (zobacz throw):

this.repository = repository ?? throw new ArgumentNullException(nameof(repository));

??= (C# 8)

x ??= y przypisuje y do x tylko wtedy, gdy x jest null. To idiom leniwej inicjalizacji:

private List<string> tags;

public void AddTag(string tag)
{
    tags ??= new List<string>();   // C# 8 and later
    tags.Add(tag);
}

Przed C# 8 pisz tags = tags ?? new List<string>(); albo if (tags == null) tags = new List<string>();.

Operator warunkowy null ?.

a?.Member oblicza Member tylko wtedy, gdy a nie jest null; w przeciwnym razie całe wyrażenie jest null. Zamienia łańcuch sprawdzeń null w jedno wyrażenie:

using System;
using System.Collections.Generic;

class Address { public string City; }
class Customer { public string Name; public Address Address; public List<string> Orders; }

class Program
{
    static void Main()
    {
        var withAddress = new Customer { Name = "Ines", Address = new Address { City = "Braga" } };
        var noAddress = new Customer { Name = "Omar" };
        Customer nobody = null;

        Console.WriteLine(withAddress.Address?.City);
        Console.WriteLine(noAddress.Address?.City ?? "(no city)");
        Console.WriteLine(nobody?.Address?.City ?? "(no customer)");

        int? orderCount = noAddress.Orders?.Count;       // int becomes int?
        Console.WriteLine(orderCount ?? 0);

        string firstOrder = noAddress.Orders?[0];         // null-conditional indexer
        Console.WriteLine(firstOrder == null);

        Action<string> onSaved = null;
        onSaved?.Invoke("saved");                          // nothing happens, no exception
        onSaved += msg => Console.WriteLine($"handler: {msg}");
        onSaved?.Invoke("saved");
    }
}

Wynik:

Braga
(no city)
(no customer)
0
True
handler: saved

Szczegóły warte poznania:

• Operator skraca resztę łańcucha: w nobody?.Address?.City, gdy tylko nobody okaże się null, nic po prawej się nie wykonuje.
• Gdy składowa zwraca typ wartościowy, wynik staje się nullable: Orders?.Count to int?, dlatego potrzebuje ?? 0, żeby znów stać się int.
• Przed C# 14 ?. nie może być celem przypisania: customer?.Name = "x" nie kompiluje się we wcześniejszych wersjach.
• handler?.Invoke(...) to standardowy sposób na wywołanie zdarzenia albo opcjonalnego callbacku.

Używaj ?. tam, gdzie null jest prawidłowym stanem. Wstawianie go wszędzie, żeby uniknąć wyjątków, ukrywa błąd, który wytworzył nieoczekiwany null, a program działa dalej z brakującymi danymi, zamiast zatrzymać się tam, gdzie leży problem.

Sprawdzanie null

if (customer == null) { ... }             // classic
if (customer is null) { ... }             // C# 7 constant pattern
if (customer != null) { ... }
if (customer is not null) { ... }         // C# 9
if (customer is { } c) { ... }            // C# 8 property pattern: not null, and named

is null zawsze wykonuje prawdziwe sprawdzenie null, a == wywołuje przeciążenie operatora danego typu, jeśli takie istnieje, więc źle napisane przeciążenie może sprawić, że x == null skłamie. Dla argumentów, które nie mogą być null, zgłaszaj błąd wcześnie:

public void Ship(Order order)
{
    ArgumentNullException.ThrowIfNull(order);   // .NET 6+
    // ...
}

Nullable reference types (C# 8)

Dodanie ? do typu wartościowego zmienia typ. Dodanie ? do typu referencyjnego, od C# 8, zmienia tylko to, co sprawdza kompilator. Gdy funkcja jest włączona (<Nullable>enable</Nullable> w pliku projektu, domyślnie w nowych projektach od .NET 6), string oznacza "nigdy nie powinno być null", a string? oznacza "może być null", i kompilator ostrzega, gdy kod do tego nie pasuje:

#nullable enable

public class User
{
    public string Email { get; set; }      // warning CS8618: Non-nullable property 'Email'
                                           // must contain a non-null value when exiting constructor.
    public string? Nickname { get; set; }  // allowed to be null

    public int NicknameLength() => Nickname.Length;
    // warning CS8602: Dereference of a possibly null reference.

    public int SafeLength() => Nickname?.Length ?? 0;   // no warning
}

string? input = Console.ReadLine();
string name = input;                       // warning CS8600: Converting null literal or possible
                                           // null value to non-nullable type.
string checkedName = input ?? "guest";     // no warning
int len = input!.Length;                   // ! tells the compiler "trust me": no warning

Kompilator śledzi twoje sprawdzenia w całej metodzie: po if (input != null) zmienna input jest traktowana jako różna od null. Operator ! (null-forgiving) wycisza ostrzeżenie, gdy wiesz więcej niż analiza; każde jego użycie to twierdzenie, którego kompilator nie może zweryfikować, więc stosuj go rzadko.

Dwa fakty, które rozwiewają większość nieporozumień. Po pierwsze, to wyłącznie ostrzeżenia: program działa tak samo, a string nadal może w czasie działania zawierać null, jeśli pochodzi z kodu bez adnotacji. Po drugie, string? to nie Nullable<string>; nie ma na nim HasValue.

Typowe błędy

• .Value bez sprawdzenia. Rzuca InvalidOperationException, gdy jest null. Użyj ??, GetValueOrDefault() albo is int n.
• Założenie, że !(x > 5) oznacza x <= 5. Nie wtedy, gdy x jest null: każde porównanie porządkowe z null jest fałszywe.
• Zasłanianie każdego null operatorem ?.. Wycisza objaw i oddala awarię od przyczyny.
• Traktowanie ostrzeżeń nullable reference jako szumu. Każde wskazuje linię, która może rzucić NullReferenceException. Popraw przepływ albo wyraź intencję za pomocą ?.
• Magiczne wartości zamiast null. -1, 0 i DateTime.MinValue jako "nieznane" wyglądają jak prawdziwe dane. Używaj int? i DateTime?.