Operatore ternario in C# (?:): sintassi, tipi, annidamento e ??

L'operatore condizionale, di solito chiamato operatore ternario, sceglie tra due valori in un'unica espressione: 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}");
        }
    }
}

Output:

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

La condizione deve essere un bool. Dopo averla valutata, viene eseguito solo uno dei due rami; l'altro non viene mai valutato. Questo rende l'operatore sicuro per gli accessi protetti come list.Count > 0 ? list[0] : "empty", dove valutare list[0] su una lista vuota lancerebbe un'eccezione.

Ternario e if/else a confronto

Il ternario è un'espressione: produce un valore che assegni, passi o restituisci. Un'istruzione if esegue istruzioni. Questi due metodi fanno la stessa cosa:

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

Usa il ternario quando entrambi i rami sono valori brevi dello stesso genere. Usa if quando un ramo esegue più istruzioni, ha effetti collaterali, oppure quando la condizione è così lunga che la riga intera non ci sta più comodamente.

Il ternario non può sostituire un if che esegue solo azioni. Questo non compila:

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

Non esiste nemmeno un ternario senza else: ? e : sono sempre obbligatori, perché l'espressione deve avere un valore in entrambi i casi.

Entrambi i rami devono avere un tipo comune

Il compilatore ricava il tipo dell'intera espressione dai suoi due rami. Un ramo deve potersi convertire implicitamente nel tipo dell'altro. Quando nessuno dei due può farlo, ottieni 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'

La soluzione è fare il cast di un ramo al tipo che vuoi, così l'altro si converte in quello:

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

Output:

no discount
7
3.5

points / 2.0 : 0 non ha bisogno di cast: 0 è un int, che si converte implicitamente in double, quindi l'espressione è un double.

C# 9 ha aggiunto la tipizzazione in base alla destinazione: quando l'espressione è assegnata a un tipo dichiarato, il compilatore usa quel tipo. int? discount = isMember ? 10 : null; compila in C# 9 e successivi. Con var non c'è un tipo di destinazione, quindi var discount = isMember ? 10 : null; fallisce ancora in ogni versione.

Precedenza e parentesi

L'operatore condizionale ha una precedenza molto bassa, più bassa di +, == e &&. È comodo in a > b ? a : b, e sorprendente dentro una concatenazione di stringhe:

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

Il compilatore legge la condizione come "Status: " + isActive, cioè una stringa. Le parentesi attorno al ternario risolvono il problema: "Status: " + (isActive ? "on" : "off").

L'interpolazione di stringhe ha una sua trappola. Dentro { }, i due punti iniziano uno specificatore di formato ({price:F2}), quindi un ternario nudo confonde il parser. Racchiudilo tra parentesi:

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

Output:

2 users online
You have 1 unread message
Status: online

Ternari annidati

L'operatore è associativo a destra, quindi a ? x : b ? y : z si raggruppa come a ? x : (b ? y : z). Una piccola catena con una condizione per riga è leggibile:

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

Output:

512 B
20 KB
5 MB

Oltre due o tre livelli, o quando le condizioni verificano cose diverse, passa a if/else if o a una switch expression. L'annidamento dentro il ramo vero (a ? (b ? x : y) : z) è la versione che diventa difficile da seguire per prima.

?? e ?. sostituiscono i ternari più comuni

Molti ternari esistono solo per gestire null. C# ha operatori più brevi per questi casi:

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

Output:

Lena from Berlin
guest from unknown
guest from unknown

Anche un'espressione throw è consentita in uno dei due rami di un ternario: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

Il ref condizionale

Da C# 7.2, un ternario può scegliere tra due variabili invece che tra due valori, e puoi assegnare tramite il risultato:

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

Entrambi i rami devono essere ref a variabili dello stesso tipo. È raro nel codice applicativo; esiste soprattutto per il codice sensibile alle prestazioni che lavora con struct grandi o array senza copiarli.