?: operator (C# reference)

The conditional operator ?:, also known as the ternary conditional operator, evaluates a Boolean expression and returns the result of one of the two expressions, depending on whether the Boolean expression evaluates to true or false, as the following example shows:

string GetWeatherDisplay(double tempInCelsius) => tempInCelsius < 20.0 ? "Cold." : "Perfect!";

Console.WriteLine(GetWeatherDisplay(15));  // output: Cold.
Console.WriteLine(GetWeatherDisplay(27));  // output: Perfect!

As the preceding example shows, the syntax for the conditional operator is as follows:

condition ? consequent : alternative

The condition expression must evaluate to true or false. If condition evaluates to true, the consequent expression is evaluated, and its result becomes the result of the operation. If condition evaluates to false, the alternative expression is evaluated, and its result becomes the result of the operation. Only consequent or alternative is evaluated.

Beginning with C# 9.0, conditional expressions are target-typed. That is, if a target type of a conditional expression is known, the types of consequent and alternative must be implicitly convertible to the target type, as the following example shows:

var rand = new Random();
var condition = rand.NextDouble() > 0.5;

int? x = condition ? 12 : null;

IEnumerable<int> xs = x is null ? new List<int>() { 0, 1 } : new int[] { 2, 3 };

If a target type of a conditional expression is unknown (for example, when you use the var keyword) or in C# 8.0 and earlier, the type of consequent and alternative must be the same or there must be an implicit conversion from one type to the other:

var rand = new Random();
var condition = rand.NextDouble() > 0.5;

var x = condition ? 12 : (int?)null;

The conditional operator is right-associative, that is, an expression of the form

a ? b : c ? d : e

is evaluated as

a ? b : (c ? d : e)

Tip

You can use the following mnemonic device to remember how the conditional operator is evaluated:

is this condition true ? yes : no

Conditional ref expression

Beginning with C# 7.2, a ref local or ref readonly local variable can be assigned conditionally with a conditional ref expression. You can also use a conditional ref expression as a reference return value or as a ref method argument.

The syntax for a conditional ref expression is as follows:

condition ? ref consequent : ref alternative

Like the original conditional operator, a conditional ref expression evaluates only one of the two expressions: either consequent or alternative.

In the case of a conditional ref expression, the type of consequent and alternative must be the same. Conditional ref expressions are not target-typed.

The following example demonstrates the usage of a conditional ref expression:

var smallArray = new int[] { 1, 2, 3, 4, 5 };
var largeArray = new int[] { 10, 20, 30, 40, 50 };

int index = 7;
ref int refValue = ref ((index < 5) ? ref smallArray[index] : ref largeArray[index - 5]);
refValue = 0;

index = 2;
((index < 5) ? ref smallArray[index] : ref largeArray[index - 5]) = 100;

Console.WriteLine(string.Join(" ", smallArray));
Console.WriteLine(string.Join(" ", largeArray));
// Output:
// 1 2 100 4 5
// 10 20 0 40 50

Conditional operator and an if..else statement

Use of the conditional operator instead of an if-else statement might result in more concise code in cases when you need conditionally to compute a value. The following example demonstrates two ways to classify an integer as negative or nonnegative:

int input = new Random().Next(-5, 5);

string classify;
if (input >= 0)
{
    classify = "nonnegative";
}
else
{
    classify = "negative";
}

classify = (input >= 0) ? "nonnegative" : "negative";

Operator overloadability

A user-defined type cannot overload the conditional operator.

C# language specification

For more information, see the Conditional operator section of the C# language specification.

For more information about features added in C# 7.2 and later, see the following feature proposal notes:

See also