? C# with Example

Returns one of two values depending on the value of a Boolean expression. 
Syntax: 
condition ? expression_if_true : expression_if_false; 
Example: 
string name = "Frank"; 
Console.WriteLine(name == "Frank" ? "The name is Frank" : "The name is not Frank"); 
The ternary operator is right-associative which allows for compound ternary expressions to be used. This is done by 
adding additional ternary equations in either the true or false position of a parent ternary equation. Care should be 
taken to ensure readability, but this can be useful shorthand in some circumstances. 
In this example, a compound ternary operation evaluates a clamp function and returns the current value if it's 
within the range, the min value if it's below the range, or the max value if it's above the range. 
light.intensity = Clamp(light.intensity, minLight, maxLight); 
public static float Clamp(float val, float min, float max) 
{ 
return (val < min) ? min : (val > max) ? max : val; 
} 
Ternary operators can also be nested, such as: 
a ? b ? "a is true, b is true" : "a is true, b is false" : "a is false" 
// This is evaluated from left to right and can be more easily seen with parenthesis: 
a ? (b ? x : y) : z 
// Where the result is x if a && b, y if a && !b, and z if !a 
When writing compound ternary statements, it's common to use parenthesis or indentation to improve readability. 
The types of expression_if_true and expression_if_false must be identical or there must be an implicit conversion from 
one to the other. 
condition ? 3 : "Not three"; // Doesn't compile because `int` and `string` lack an implicit 
conversion. 
condition ? 3.ToString() : "Not three"; // OK because both possible outputs are strings. 
condition ? 3 : 3.5; // OK because there is an implicit conversion from `int` to `double`. The 
ternary operator will return a `double`. 
condition ? 3.5 : 3; // OK because there is an implicit conversion from `int` to `double`. The 
ternary operator will return a `double`. 
 

The type and conversion requirements apply to your own classes too. 
public class Car 
{} 
public class SportsCar : Car 
{} 
public class SUV : Car 
{} 
condition ? new SportsCar() : new Car(); // OK because there is an implicit conversion from 
`SportsCar` to `Car`. The ternary operator will return a reference of type `Car`. 
condition ? new Car() : new SportsCar(); // OK because there is an implicit conversion from 
`SportsCar` to `Car`. The ternary operator will return a reference of type `Car`. 
condition ? new SportsCar() : new SUV(); // Doesn't compile because there is no implicit conversion 
from  `SportsCar`  to  SUV  or  `SUV`  to  `SportsCar`.  The  compiler  is not  smart  enough  to  realize that 
both of them have an implicit conversion to `Car`. 
condition ? new SportsCar() as Car : new SUV() as Car; // OK because both expressions evaluate to a 
reference of type `Car`. The ternary operator will return a reference of type `Car`.