> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# Conditional The `?:` operator, formally known as the ternary conditional operator, evaluates a boolean expression and returns the result of one of two mutually exclusive expressions based on that evaluation. It is an expression-based construct, meaning it resolves to a value, unlike the statement-based `if-else` control flow. ```csharp theme={"dark"} bool condition = true; int consequent = 1; int alternative = 0; int result = condition ? consequent : alternative; ``` ## Evaluation Mechanics The operator requires three operands: 1. **`condition`**: An expression that must be implicitly convertible to `bool`, or a type that explicitly overloads the `true` and `false` operators. 2. **`consequent`**: The expression evaluated and returned if the `condition` evaluates to `true`. 3. **`alternative`**: The expression evaluated and returned if the `condition` evaluates to `false`. The operator enforces **short-circuit evaluation**. The compiler guarantees that only one of the two result expressions is evaluated. If `condition` is `true`, `consequent` is evaluated and `alternative` is ignored. If `condition` is `false`, `alternative` is evaluated and `consequent` is ignored. ## Type Resolution The compiler must determine a single return type for the entire ternary expression. The rules for type resolution depend on the C# version: * **Standard Type Resolution:** There must be an implicit conversion from the type of the `consequent` to the type of the `alternative`, or vice versa. If neither conversion exists, or if both exist (creating an ambiguity), the compiler throws an error. * **Target-Typed Conditional Expressions (C# 9.0+):** If the `consequent` and `alternative` do not share a common type, the expression is valid provided both types are implicitly convertible to the target type of the assignment or context. ```csharp theme={"dark"} using System.Collections.Generic; bool condition = true; // Standard resolution: 'int' implicitly converts to 'double' double result = condition ? 10.5 : 5; // Target-typed resolution (C# 9.0+): Both convert to 'IEnumerable' IEnumerable sequence = condition ? new List() : new int[5]; ``` ## Associativity The ternary operator is **right-associative**. When multiple conditional operators are chained, they are grouped from right to left. ```csharp theme={"dark"} bool a = true; bool c = false; int b = 1, d = 2, e = 3; // The expression: int chainedResult = a ? b : c ? d : e; // Is evaluated by the compiler as: int groupedResult = a ? b : (c ? d : e); ``` ## Ref Conditional Operator Starting with C# 7.2, the ternary operator can be used to return a variable reference (`ref`) rather than a value. Both the `consequent` and `alternative` must be `ref` expressions of the exact same type. When assigning the result to a `ref` local, the entire ternary expression must be enclosed in parentheses to parse correctly. ```csharp theme={"dark"} bool condition = true; int variable1 = 10; int variable2 = 20; ref int reference = ref (condition ? ref variable1 : ref variable2); ``` ## Restrictions * The `?:` operator cannot be overloaded via user-defined operator overloading. * Because it is an expression, it cannot be used as a standalone statement; its result must be assigned, passed as an argument, or returned.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More