Skip to main content

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.

A switch expression is a pattern-matching construct introduced in C# 8.0 that evaluates a target object against a series of patterns and returns a single value based on the first matching pattern. Unlike the traditional switch statement, which executes blocks of code via control flow, a switch expression is an expression that yields a result, enabling more concise syntax and functional programming paradigms.

​
Core Syntax

The syntax reverses the traditional order by placing the target expression before the switch keyword, followed by a comma-separated list of expression arms. 
return_type result = target_expression switch
{
    pattern_1 => expression_1,
    pattern_2 => expression_2,
    _ => default_expression
};

​
Technical Mechanics

  • Target Expression: The variable or value being evaluated.
  • Expression Arms: Each arm consists of a pattern, a fat arrow (=>), and the expression to return if the pattern matches. Arms are separated by commas, not semicolons.
  • Discard Pattern (_): Functions as the default catch-all. It matches any value that has not been matched by preceding patterns.
  • Exhaustiveness Checking: The C# compiler performs static analysis to ensure all possible values of the target expression’s type are handled. If the compiler detects missing patterns, it generates a warning (CS8509).
  • Runtime Behavior: If a switch expression evaluates a value that does not match any pattern and no discard pattern is provided, the runtime throws a System.Runtime.CompilerServices.SwitchExpressionException.

​
Supported Pattern Types

Switch expressions leverage the full C# pattern-matching engine, allowing for complex evaluations within a single arm. 1. Constant and Relational Patterns Evaluates exact values or compares values using relational operators (<, >, <=, >=). 
int status = code switch
{
    200 => 1,
    >= 400 and < 500 => -1, // Relational and logical patterns combined
    _ => 0
};
2. Type and Declaration Patterns Checks the runtime type of the target expression and optionally binds it to a new local variable. 
string typeInfo = shape switch
{
    Circle c => $"Circle with radius {c.Radius}",
    Rectangle r => $"Rectangle {r.Length}x{r.Width}",
    null => "Null reference",
    _ => "Unknown shape"
};
3. Property Patterns Matches against the properties or fields of the target object. 
decimal discount = customer switch
{
    { IsPremium: true, YearsActive: >= 5 } => 0.20m,
    { IsPremium: true } => 0.10m,
    _ => 0.0m
};
4. Positional (Tuple) Patterns Evaluates multiple values simultaneously by deconstructing them into a tuple. 
string quadrant = (x, y) switch
{
    (0, 0) => "Origin",
    (> 0, > 0) => "Q1",
    (< 0, > 0) => "Q2",
    (_, 0) => "X-Axis", // Discard used for a specific tuple element
    _ => "Other"
};

​
Case Guards

When a pattern alone is insufficient to express the required logic, a when clause (case guard) can be appended to an expression arm. The arm will only match if both the pattern matches and the boolean expression in the when clause evaluates to true. 
string evaluation = (x, y) switch
{
    (var a, var b) when a == b => "Symmetrical",
    (var a, var b) when a > b => "X-Dominant",
    _ => "Y-Dominant"
};
Master C# with Deep Grasping Methodology!Learn More