Operator trójargumentowy w C# (?:): składnia, typy, zagnieżdżanie i ??

Operator warunkowy, zwykle nazywany operatorem trójargumentowym (ternary), wybiera między dwiema wartościami w jednym wyrażeniu: condition ? valueIfTrue : valueIfFalse.

using System;

class Program
{
    static void Main()
    {
        int[] cartSizes = { 0, 1, 5 };

        foreach (int count in cartSizes)
        {
            string noun = count == 1 ? "item" : "items";
            decimal shipping = count >= 5 ? 0m : 4.99m;
            Console.WriteLine($"{count} {noun}, shipping {shipping}");
        }
    }
}

Wynik:

0 items, shipping 4.99
1 item, shipping 4.99
5 items, shipping 0

Warunek musi być typu bool. Po jego obliczeniu wykonuje się tylko jedna z dwóch gałęzi; druga nigdy nie jest obliczana. Dzięki temu operator nadaje się do bezpiecznego dostępu, jak list.Count > 0 ? list[0] : "empty", gdzie obliczenie list[0] na pustej liście rzuciłoby wyjątek.

Operator trójargumentowy a if/else

Operator trójargumentowy to wyrażenie: daje wartość, którą przypisujesz, przekazujesz albo zwracasz. Instrukcja if wykonuje instrukcje. Te dwie metody robią to samo:

// with if/else
static string Status(int stock)
{
    if (stock > 0)
        return "in stock";
    else
        return "sold out";
}

// with the ternary
static string Status(int stock) => stock > 0 ? "in stock" : "sold out";

Używaj operatora trójargumentowego, gdy obie gałęzie to krótkie wartości tego samego rodzaju. Używaj if, gdy gałąź wykonuje kilka instrukcji, ma efekty uboczne albo gdy warunek jest na tyle długi, że cała linia przestaje się wygodnie mieścić.

Operator trójargumentowy nie zastąpi if, który tylko wykonuje akcje. To się nie kompiluje:

stock > 0 ? Ship(order) : Refund(order);
// error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement

Nie ma też operatora trójargumentowego bez else: ? i : są zawsze wymagane, bo wyrażenie musi mieć wartość w obu przypadkach.

Obie gałęzie potrzebują wspólnego typu

Kompilator ustala typ całego wyrażenia na podstawie jego dwóch gałęzi. Jedna gałąź musi dać się niejawnie przekonwertować na typ drugiej. Gdy żadna się nie da, dostajesz CS0173:

var discount = isMember ? 10 : null;
// error CS0173: Type of conditional expression cannot be determined because
// there is no implicit conversion between 'int' and '<null>'

var label = inStock ? 1 : "none";
// error CS0173: ... between 'int' and 'string'

Rozwiązaniem jest rzutowanie jednej gałęzi na typ, którego chcesz, żeby druga się na niego przekonwertowała:

using System;

class Program
{
    static void Main()
    {
        bool isMember = false;
        int points = 7;

        int? discount = isMember ? (int?)10 : null;
        object reward = points > 5 ? (object)points : "none";
        double average = points > 0 ? points / 2.0 : 0;

        Console.WriteLine(discount.HasValue ? $"{discount}%" : "no discount");
        Console.WriteLine(reward);
        Console.WriteLine(average.ToString("F1"));
    }
}

Wynik:

no discount
7
3.5

points / 2.0 : 0 nie wymaga rzutowania: 0 to int, który niejawnie konwertuje się na double, więc wyrażenie jest typu double.

C# 9 dodał typowanie docelowe: gdy wyrażenie jest przypisywane do zadeklarowanego typu, kompilator używa tego typu. int? discount = isMember ? 10 : null; kompiluje się w C# 9 i nowszych. Z var nie ma typu docelowego, więc var discount = isMember ? 10 : null; nadal zawodzi w każdej wersji.

Priorytet i nawiasy

Operator warunkowy ma bardzo niski priorytet, niższy niż +, == i &&. W a > b ? a : b jest to wygodne, a wewnątrz łączenia stringów zaskakujące:

Console.WriteLine("Status: " + isActive ? "on" : "off");
// error CS0029: Cannot implicitly convert type 'string' to 'bool'

Kompilator odczytuje warunek jako "Status: " + isActive, czyli string. Nawiasy wokół operatora trójargumentowego to naprawiają: "Status: " + (isActive ? "on" : "off").

Interpolacja stringów ma własną pułapkę. Wewnątrz { } dwukropek rozpoczyna specyfikator formatu ({price:F2}), więc goły operator trójargumentowy myli parser. Otocz go nawiasami:

using System;

class Program
{
    static void Main()
    {
        string[] users = { "ana", "ben" };
        int unread = 1;
        bool online = true;

        Console.WriteLine($"{users.Length} {(users.Length == 1 ? "user" : "users")} online");
        Console.WriteLine($"You have {unread} unread {(unread == 1 ? "message" : "messages")}");
        Console.WriteLine($"Status: {(online ? "online" : "away")}");
    }
}

Wynik:

2 users online
You have 1 unread message
Status: online

Zagnieżdżone operatory trójargumentowe

Operator jest prawostronnie łączny, więc a ? x : b ? y : z grupuje się jako a ? x : (b ? y : z). Krótki łańcuch rozpisany po jednym warunku na linię jest czytelny:

using System;

class Program
{
    static string Size(int bytes) =>
        bytes < 1024 ? $"{bytes} B" :
        bytes < 1024 * 1024 ? $"{bytes / 1024} KB" :
        $"{bytes / (1024 * 1024)} MB";

    static void Main()
    {
        Console.WriteLine(Size(512));
        Console.WriteLine(Size(20480));
        Console.WriteLine(Size(5242880));
    }
}

Wynik:

512 B
20 KB
5 MB

Powyżej dwóch lub trzech poziomów albo gdy warunki sprawdzają różne rzeczy, przejdź na if/else if albo wyrażenie switch. Zagnieżdżanie w gałęzi true (a ? (b ? x : y) : z) to wersja, która najszybciej staje się trudna do śledzenia.

?? i ?. zastępują typowe operatory trójargumentowe

Wiele operatorów trójargumentowych istnieje tylko po to, żeby obsłużyć null. C# ma do tego krótsze operatory:

using System;

class Address { public string City; }
class Customer { public string Name; public Address Address; }

class Program
{
    static void Main()
    {
        Customer[] customers =
        {
            new Customer { Name = "Lena", Address = new Address { City = "Berlin" } },
            new Customer { Name = null, Address = null },
            null,
        };

        foreach (Customer c in customers)
        {
            string name = c?.Name ?? "guest";
            string city = c?.Address?.City ?? "unknown";
            Console.WriteLine($"{name} from {city}");
        }
    }
}

Wynik:

Lena from Berlin
guest from unknown
guest from unknown

Wyrażenie throw jest też dozwolone jako dowolna gałąź operatora trójargumentowego: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

Warunkowy ref

Od C# 7.2 operator trójargumentowy może wybierać między dwiema zmiennymi zamiast dwóch wartości, a przez wynik można przypisywać:

// C# 7.2 and later
int wins = 0, losses = 0;
bool won = true;

ref int counter = ref (won ? ref wins : ref losses);
counter++;               // increments wins

Obie gałęzie muszą być ref do zmiennych tego samego typu. W kodzie aplikacji to rzadkość; istnieje głównie dla kodu wrażliwego na wydajność, który pracuje z dużymi strukturami albo tablicami bez ich kopiowania.