C# Ternärer Operator (?:): Syntax, Typen, Verschachtelung und ??

Der Bedingungsoperator, meist ternärer Operator genannt, wählt in einem einzigen Ausdruck zwischen zwei Werten: 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}");
        }
    }
}

Ausgabe:

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

Die Bedingung muss ein bool sein. Nach ihrer Auswertung läuft nur einer der beiden Zweige; der andere wird nie ausgewertet. Das macht den Operator sicher für abgesicherte Zugriffe wie list.Count > 0 ? list[0] : "empty", wo die Auswertung von list[0] bei einer leeren Liste werfen würde.

Ternärer Operator gegenüber if/else

Der ternäre Operator ist ein Ausdruck: Er erzeugt einen Wert, den du zuweist, übergibst oder zurückgibst. Eine if-Anweisung führt Anweisungen aus. Diese beiden Methoden tun dasselbe:

// 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";

Nimm den ternären Operator, wenn beide Zweige kurze Werte derselben Art sind. Nimm if, wenn ein Zweig mehrere Anweisungen ausführt, Nebeneffekte hat oder die Bedingung so lang ist, dass die ganze Zeile nicht mehr bequem passt.

Der ternäre Operator kann kein if ersetzen, das nur Aktionen ausführt. Das hier kompiliert nicht:

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

Es gibt auch keinen ternären Operator ohne else: ? und : sind immer Pflicht, weil der Ausdruck in beiden Fällen einen Wert haben muss.

Beide Zweige brauchen einen gemeinsamen Typ

Der Compiler ermittelt den Typ des ganzen Ausdrucks aus seinen beiden Zweigen. Ein Zweig muss sich implizit in den Typ des anderen umwandeln lassen. Geht das in keine Richtung, bekommst du 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'

Die Lösung ist, einen Zweig in den gewünschten Typ zu casten, damit sich der andere dorthin umwandeln lässt:

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"));
    }
}

Ausgabe:

no discount
7
3.5

points / 2.0 : 0 braucht keinen Cast: 0 ist ein int, das sich implizit in double umwandeln lässt, also ist der Ausdruck ein double.

C# 9 hat Zieltypisierung hinzugefügt: Wird der Ausdruck einem deklarierten Typ zugewiesen, verwendet der Compiler diesen Typ. int? discount = isMember ? 10 : null; kompiliert ab C# 9. Mit var gibt es keinen Zieltyp, var discount = isMember ? 10 : null; scheitert also in jeder Version.

Rangfolge und Klammern

Der Bedingungsoperator hat eine sehr niedrige Rangfolge, niedriger als +, == und &&. Das ist praktisch in a > b ? a : b und überraschend innerhalb einer String-Verkettung:

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

Der Compiler liest die Bedingung als "Status: " + isActive, also als String. Klammern um den ternären Ausdruck beheben das: "Status: " + (isActive ? "on" : "off").

Die String-Interpolation hat ihre eigene Falle. Innerhalb von { } leitet ein Doppelpunkt einen Formatbezeichner ein ({price:F2}), ein nackter ternärer Ausdruck verwirrt also den Parser. Setze ihn in Klammern:

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")}");
    }
}

Ausgabe:

2 users online
You have 1 unread message
Status: online

Verschachtelte ternäre Operatoren

Der Operator ist rechtsassoziativ, a ? x : b ? y : z gruppiert sich also als a ? x : (b ? y : z). Eine kleine Kette mit einer Bedingung pro Zeile ist lesbar:

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));
    }
}

Ausgabe:

512 B
20 KB
5 MB

Ab zwei oder drei Ebenen oder wenn die Bedingungen verschiedene Dinge prüfen, wechsle zu if/else if oder einem switch-Ausdruck. Die Verschachtelung im true-Zweig (a ? (b ? x : y) : z) ist die Variante, die zuerst schwer nachzuvollziehen wird.

?? und ?. ersetzen häufige ternäre Ausdrücke

Viele ternäre Ausdrücke existieren nur, um null zu behandeln. Dafür hat C# kürzere Operatoren:

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}");
        }
    }
}

Ausgabe:

Lena from Berlin
guest from unknown
guest from unknown

Ein throw-Ausdruck ist auch als einer der beiden Zweige eines ternären Operators erlaubt: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

Der ref-Bedingungsausdruck

Seit C# 7.2 kann ein ternärer Ausdruck zwischen zwei Variablen statt zwei Werten wählen, und du kannst über das Ergebnis zuweisen:

// 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

Beide Zweige müssen ref auf Variablen desselben Typs sein. In Anwendungscode ist das selten; es existiert vor allem für performancekritischen Code, der mit großen Structs oder Arrays arbeitet, ohne sie zu kopieren.