Operador ternario en C# (?:): sintaxis, tipos, anidación y ??

El operador condicional, que suele llamarse operador ternario, elige entre dos valores en una sola expresión: 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}");
        }
    }
}

Salida:

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

La condición debe ser un bool. Una vez evaluada, solo una de las dos ramas se ejecuta; la otra nunca se evalúa. Eso hace que el operador sea seguro para accesos protegidos como list.Count > 0 ? list[0] : "empty", donde evaluar list[0] sobre una lista vacía lanzaría una excepción.

Ternario frente a if/else

El ternario es una expresión: produce un valor que asignas, pasas o devuelves. Una sentencia if ejecuta sentencias. Estos dos métodos hacen lo mismo:

// 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 el ternario cuando las dos ramas son valores cortos del mismo tipo. Usa if cuando una rama ejecuta varias sentencias, tiene efectos secundarios, o cuando la condición es tan larga que la línea entera ya no cabe con comodidad.

El ternario no puede sustituir a un if que solo realiza acciones. Esto no 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

Tampoco existe un ternario sin else: ? y : siempre son obligatorios, porque la expresión debe tener un valor en los dos casos.

Las dos ramas necesitan un tipo común

El compilador deduce el tipo de la expresión completa a partir de sus dos ramas. Una rama debe convertirse implícitamente al tipo de la otra. Cuando ninguna lo hace, obtienes 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 solución es hacer un cast de una rama al tipo que quieres, para que la otra se convierta a él:

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

Salida:

no discount
7
3.5

points / 2.0 : 0 no necesita cast: 0 es un int, que se convierte implícitamente a double, así que la expresión es un double.

C# 9 añadió el tipado por destino: cuando la expresión se asigna a un tipo declarado, el compilador usa ese tipo. int? discount = isMember ? 10 : null; compila en C# 9 y posteriores. Con var no hay tipo de destino, así que var discount = isMember ? 10 : null; sigue fallando en todas las versiones.

Precedencia y paréntesis

El operador condicional tiene una precedencia muy baja, menor que +, == y &&. Eso es cómodo en a > b ? a : b, y sorprendente dentro de una concatenación de strings:

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

El compilador lee la condición como "Status: " + isActive, un string. Los paréntesis alrededor del ternario lo arreglan: "Status: " + (isActive ? "on" : "off").

La interpolación de strings tiene su propia trampa. Dentro de { }, los dos puntos inician un especificador de formato ({price:F2}), así que un ternario sin paréntesis confunde al parser. Envuélvelo en paréntesis:

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

Salida:

2 users online
You have 1 unread message
Status: online

Ternarios anidados

El operador es asociativo por la derecha, así que a ? x : b ? y : z se agrupa como a ? x : (b ? y : z). Una cadena pequeña con una condición por línea es legible:

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

Salida:

512 B
20 KB
5 MB

Pasados dos o tres niveles, o cuando las condiciones prueban cosas distintas, cambia a if/else if o a una expresión switch. Anidar dentro de la rama verdadera (a ? (b ? x : y) : z) es la versión que antes se vuelve difícil de seguir.

?? y ?. sustituyen a ternarios habituales

Muchos ternarios existen solo para manejar null. C# tiene operadores más cortos para esos casos:

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

Salida:

Lena from Berlin
guest from unknown
guest from unknown

Una expresión throw también se permite en cualquiera de las ramas de un ternario: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

El condicional ref

Desde C# 7.2, un ternario puede elegir entre dos variables en lugar de dos valores, y puedes asignar a través del resultado:

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

Las dos ramas deben ser ref a variables del mismo tipo. Es raro en código de aplicación; existe sobre todo para código sensible al rendimiento que trabaja con structs o arrays grandes sin copiarlos.