Constant patterns in C Sharp (C#) - Deep Dive

Overview - Constant patterns

What is it?

Constant patterns in C# let you check if a value matches a specific constant directly inside a pattern matching expression. Instead of writing full if statements, you can write concise code that compares a value to a fixed constant like a number, string, or boolean. This makes your code easier to read and understand by clearly showing the exact value you want to match.

Why it matters

Without constant patterns, checking for specific values requires longer, more repetitive code with if or switch statements. Constant patterns simplify this by embedding the value check inside the pattern itself, reducing mistakes and making your intentions clearer. This helps you write safer, cleaner, and more maintainable code, especially when handling many possible values.

Where it fits

Before learning constant patterns, you should understand basic C# syntax, variables, and simple if or switch statements. After mastering constant patterns, you can explore more advanced pattern matching features like type patterns, property patterns, and relational patterns to write even more expressive code.

Mental Model

Core Idea

A constant pattern checks if a value exactly equals a fixed constant inside a pattern matching expression.

Think of it like...

It's like checking if a key fits exactly into a specific lock; if it matches perfectly, you open the door (run the code).

Value to check
   │
   ▼
┌───────────────┐
│ Constant      │
│ Pattern       │
│ (e.g., 42)    │
└───────────────┘
   │
   ▼
Match? Yes → run code block
No → try other patterns or skip

Build-Up - 6 Steps

1

Foundation

Understanding basic pattern matching

Concept: Introduce the idea of pattern matching in C# as a way to check values against patterns.

In C#, pattern matching lets you compare a value against a pattern inside a switch or an if statement. For example: int number = 5; switch (number) { case 5: Console.WriteLine("Number is five"); break; default: Console.WriteLine("Number is something else"); break; } Here, the case 5 is a simple constant pattern checking if number equals 5.

Result

Output: Number is five

Understanding that switch cases can act as simple constant patterns lays the groundwork for more explicit constant pattern syntax.

2

Foundation

Using constant patterns in if statements

Concept: Show how constant patterns can be used with the 'is' keyword in if statements.

Instead of switch, you can use constant patterns with 'is' in if statements: int x = 10; if (x is 10) { Console.WriteLine("x is ten"); } else { Console.WriteLine("x is not ten"); } This checks if x equals the constant 10 directly.

Result

Output: x is ten

Using 'is' with a constant pattern makes simple equality checks more readable and concise.

3

Intermediate

Matching different constant types

🤔Before reading on: do you think constant patterns work only with numbers, or also with strings and booleans? Commit to your answer.

Concept: Constant patterns can match many types of constants, not just numbers.

You can use constant patterns with strings, booleans, enums, and more: string color = "red"; if (color is "red") { Console.WriteLine("Color is red"); } bool flag = true; if (flag is true) { Console.WriteLine("Flag is true"); } This flexibility lets you match many fixed values easily.

Result

Output: Color is red Flag is true

Knowing constant patterns work with many types helps you write clearer code for different scenarios.

4

Intermediate

Combining constant patterns with switch expressions

🤔Before reading on: do you think switch expressions can use constant patterns to return values directly? Commit to your answer.

Concept: Switch expressions use constant patterns to return results based on matching constants.

Switch expressions let you write compact code: int day = 3; string dayName = day switch { 1 => "Monday", 2 => "Tuesday", 3 => "Wednesday", _ => "Unknown" }; Console.WriteLine(dayName); Each number is a constant pattern matching day to return a string.

Result

Output: Wednesday

Using constant patterns in switch expressions makes mapping values to results concise and readable.

5

Advanced

Constant patterns with nullable and reference types

🤔Before reading on: do you think constant patterns can match null values? Commit to your answer.

Concept: Constant patterns can match null and work with nullable or reference types safely.

You can check for null explicitly: string? name = null; if (name is null) { Console.WriteLine("Name is null"); } else { Console.WriteLine("Name is not null"); } This helps avoid null reference errors by handling null cases clearly.

Result

Output: Name is null

Recognizing that constant patterns handle null checks improves safety and clarity in your code.

6

Expert

Compiler optimizations and pattern matching internals

🤔Before reading on: do you think constant patterns always compile to simple equality checks, or can they be optimized differently? Commit to your answer.

Concept: The compiler optimizes constant patterns to efficient code, sometimes using jump tables or direct comparisons.

When you write constant patterns, the C# compiler generates optimized code: - For small sets of constants, it uses direct equality checks. - For many constants in switch expressions, it may generate jump tables for speed. - Nullable and reference type checks become null checks or reference equality. This means your readable pattern code runs fast without extra overhead.

Result

Your pattern matching code runs efficiently at runtime.

Understanding compiler optimizations helps you trust pattern matching for performance-critical code.

Under the Hood

Constant patterns work by the compiler generating code that compares the input value to the specified constant using equality checks. For value types like int or bool, this is a simple value comparison. For reference types like strings, it uses content equality as defined. When used in switch expressions, the compiler may generate jump tables or optimized branching to speed up matching multiple constants. Null constants are checked with direct null comparisons. The pattern matching syntax is syntactic sugar that compiles down to these efficient checks.

Why designed this way?

Constant patterns were introduced to make code more readable and expressive by embedding value checks directly in patterns. Before, developers had to write verbose if or switch statements with explicit comparisons. The design balances simplicity and performance by compiling patterns into efficient code, avoiding runtime overhead. Alternatives like method calls or manual comparisons were less clear and more error-prone, so constant patterns provide a clean, declarative way to express fixed value matches.

Input Value
   │
   ▼
┌───────────────┐
│ Constant      │
│ Pattern       │
│ (e.g., 42)    │
└───────────────┘
   │
   ▼
Equality Check ──► True? ──► Execute matched code
                   │
                   ▼
                 False
                   │
                   ▼
             Try next pattern or default

Myth Busters - 4 Common Misconceptions

Quick: Does 'x is 5' check if x is the same object as 5, or if x equals 5 in value? Commit to your answer.

Common Belief: People often think 'x is 5' means x and 5 are the exact same object in memory.

Reality: 'x is 5' checks if x equals 5 in value, not if they are the same object instance.

Why it matters: Confusing reference equality with value equality can lead to bugs when matching strings or objects.

Quick: Can constant patterns be used with variables instead of fixed constants? Commit to your answer.

Common Belief: Some believe constant patterns can match any variable value, not just fixed constants.

Reality: Constant patterns only match fixed compile-time constants, not variables or expressions.

Why it matters: Trying to use variables in constant patterns causes compile errors and confusion.

Quick: Does 'is null' pattern only work with reference types? Commit to your answer.

Common Belief: Many think 'is null' only applies to reference types and not nullable value types.

Reality: 'is null' works with both reference types and nullable value types to check for null.

Why it matters: Misunderstanding this can cause missed null checks and runtime exceptions.

Quick: Do you think constant patterns always generate slower code than if statements? Commit to your answer.

Common Belief: Some believe pattern matching with constant patterns is slower than traditional if statements.

Reality: The compiler often generates equally fast or faster code using jump tables or optimized branching.

Why it matters: Avoiding constant patterns due to performance fears can lead to less readable and maintainable code.

Expert Zone

1

Constant patterns with enums are compiled to integer comparisons, but using named enum constants improves readability and maintainability.

2

When combining constant patterns with other patterns (like property or type patterns), the order of evaluation affects performance and correctness.

3

Nullable constant patterns can sometimes cause subtle bugs if you forget to handle the null case explicitly.

When NOT to use

Avoid constant patterns when you need to match complex conditions or ranges; use relational or property patterns instead. Also, do not use constant patterns with non-constant expressions or variables, as they cause compile errors. For performance-critical code with many cases, consider if a dictionary lookup or polymorphism is more appropriate.

Production Patterns

In production, constant patterns are widely used in switch expressions for mapping codes to messages, handling enums, and checking fixed flags. They simplify validation logic and replace verbose if-else chains. Experts combine constant patterns with other pattern types to write clear, concise, and maintainable decision logic in APIs, UI code, and business rules.

Connections

Relational patterns

Builds-on

Understanding constant patterns helps grasp relational patterns, which compare values using operators like < or > instead of exact equality.

Finite state machines (FSM)

Same pattern

Constant patterns in switch statements resemble FSM transitions where each constant represents a state or input triggering a specific action.

Mathematical equality

Same pattern

Constant patterns rely on the concept of equality from math, showing how programming patterns mirror fundamental math ideas.

Common Pitfalls

#1 Trying to use a variable instead of a constant in a pattern.

Wrong approach:

int x = 5;
int y = 10;
if (x is y) // Error: y is not a constant
{
Console.WriteLine("x matches y");
}

Correct approach:

const int y = 10;
int x = 5;
if (x is y)
{
Console.WriteLine("x matches y");
}

Root cause:

Misunderstanding that constant patterns require compile-time constants, not variables.

#2 Using 'is' with a constant pattern but forgetting to handle null values.

Wrong approach:

string? name = null;
if (name is "Alice")
{
Console.WriteLine("Hello Alice");
}
// No null check, may cause unexpected behavior

Correct approach:

string? name = null;
if (name is null)
{
Console.WriteLine("Name is null");
}
else if (name is "Alice")
{
Console.WriteLine("Hello Alice");
}

Root cause:

Overlooking null as a possible value when matching reference or nullable types.

#3 Assuming constant patterns check reference equality for strings.

Wrong approach:

string s = new string(new[] {'h','i'});
if (s is "hi")
{
Console.WriteLine("Matched");
}
// Might fail if reference equality was used

Correct approach:

string s = new string(new[] {'h','i'});
if (s is "hi") // uses content equality
{
Console.WriteLine("Matched");
}

Root cause:

Confusing reference equality with value/content equality in string comparisons.

Key Takeaways

Constant patterns let you check if a value equals a fixed constant directly inside pattern matching expressions.

They work with many types including numbers, strings, booleans, enums, and null values.

Using constant patterns makes your code shorter, clearer, and easier to maintain compared to traditional if or switch statements.

The compiler optimizes constant patterns to efficient code, so you don't lose performance by using them.

Understanding constant patterns is a foundation for mastering more advanced pattern matching features in C#.