C# Ternary Operator (?:): Syntax, Types, Nesting and ??

The conditional operator, usually called the ternary operator, chooses between two values in a single expression: 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

The condition must be a bool. After it is evaluated, only one of the two branches runs; the other is never evaluated. That makes the operator safe for guarded access such as list.Count > 0 ? list[0] : "empty", where evaluating list[0] on an empty list would throw.

Ternary Versus if/else

The ternary is an expression: it produces a value that you assign, pass or return. An if statement runs statements. These two methods do the same thing:

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

Use the ternary when both branches are short values of the same kind. Use if when a branch runs several statements, has side effects, or when the condition is long enough that the whole line no longer fits comfortably.

The ternary cannot replace an if that only performs actions. This does not compile:

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

There is also no ternary without an else: both ? and : are always required, because the expression must have a value in both cases.

Both Branches Need a Common Type

The compiler works out the type of the whole expression from its two branches. One branch must convert implicitly to the other's type. When neither does, you get 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'

The fix is to cast one branch to the type you want, so the other converts to it:

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 needs no cast: 0 is an int, which converts implicitly to double, so the expression is a double.

C# 9 added target typing: when the expression is assigned to a declared type, the compiler uses that type. int? discount = isMember ? 10 : null; compiles in C# 9 and later. With var there is no target type, so var discount = isMember ? 10 : null; still fails in every version.

Precedence and Parentheses

The conditional operator has very low precedence, lower than +, == and &&. That is convenient in a > b ? a : b, and surprising inside string concatenation:

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

The compiler reads the condition as "Status: " + isActive, a string. Parentheses around the ternary fix it: "Status: " + (isActive ? "on" : "off").

String interpolation has its own trap. Inside { }, a colon starts a format specifier ({price:F2}), so a bare ternary confuses the parser. Wrap it in parentheses:

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

Nested Ternaries

The operator is right-associative, so a ? x : b ? y : z groups as a ? x : (b ? y : z). A small chain laid out one condition per line is readable:

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

Past two or three levels, or when conditions test different things, switch to if/else if or a switch expression. Nesting inside the true branch (a ? (b ? x : y) : z) is the version that becomes hard to follow first.

?? and ?. Replace Common Ternaries

Many ternaries exist only to handle null. C# has shorter operators for those:

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

A throw expression is also allowed as either branch of a ternary: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

The ref Conditional

Since C# 7.2, a ternary can choose between two variables rather than two values, and you can assign through the result:

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

Both branches must be ref to variables of the same type. It is rare in application code; it exists mainly for performance-sensitive code that works with large structs or arrays without copying them.