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

Overview - Relational patterns

What is it?

Relational patterns in C# let you compare values directly inside a pattern matching expression. They allow you to check if a value is less than, greater than, or equal to another value in a clear and concise way. This helps you write conditions that are easy to read and understand. Instead of writing long if statements, you can use relational patterns to match values quickly.

Why it matters

Without relational patterns, programmers write many nested if-else statements to compare values, which can be confusing and error-prone. Relational patterns simplify these comparisons, making code cleaner and easier to maintain. This leads to fewer bugs and faster development, especially when dealing with ranges or thresholds in data.

Where it fits

Before learning relational patterns, you should understand basic pattern matching and comparison operators in C#. After mastering relational patterns, you can explore more complex patterns like logical patterns and property patterns to write even more expressive code.

Mental Model

Core Idea

Relational patterns let you directly compare a value against a condition inside a pattern match, making conditional checks simpler and clearer.

Think of it like...

It's like sorting mail by size: instead of checking each letter with many questions, you just say 'Is it bigger than this?' or 'Is it smaller than that?' and quickly put it in the right pile.

Value to check
   │
   ▼
┌───────────────┐
│ Relational    │
│ Pattern:      │
│ < 10, > 5, == 7│
└───────────────┘
   │
   ▼
True or False result

Build-Up - 6 Steps

1

Foundation

Basic comparison operators review

Concept: Understanding how to compare values using operators like <, >, <=, >=, ==, and !=.

In C#, you can compare numbers or other values using operators: int x = 7; bool isLess = x < 10; // true bool isEqual = x == 7; // true These operators return true or false depending on the comparison.

Result

You can check if a value is less than, greater than, or equal to another value.

Knowing these operators is essential because relational patterns use them inside pattern matching to simplify comparisons.

2

Foundation

Introduction to pattern matching

Concept: Learning how to use pattern matching with the 'switch' expression and 'is' keyword.

Pattern matching lets you check a value against patterns: int number = 5; switch (number) { case 1: Console.WriteLine("One"); break; case 5: Console.WriteLine("Five"); break; default: Console.WriteLine("Other"); break; } This matches the value to cases.

Result

You can match values to specific patterns and run code accordingly.

Pattern matching is the foundation that relational patterns build on to make comparisons inside matches easier.

3

Intermediate

Using relational patterns in 'switch' expressions

🤔Before reading on: do you think you can use '< 10' directly inside a switch case in C#? Commit to your answer.

Concept: Relational patterns allow you to use comparison operators directly in switch cases to match ranges or conditions.

You can write: int age = 25; switch (age) { case < 13: Console.WriteLine("Child"); break; case < 20: Console.WriteLine("Teenager"); break; case >= 20: Console.WriteLine("Adult"); break; } This checks if age is less than 13, less than 20, or 20 and above.

Result

The program prints 'Adult' because 25 is >= 20.

Understanding that relational patterns let you write conditions directly inside switch cases makes your code more readable and concise.

4

Intermediate

Combining relational patterns with logical patterns

🤔Before reading on: can you combine relational patterns with 'and' or 'or' in C# pattern matching? Commit to your answer.

Concept: You can combine relational patterns using logical patterns like 'and' and 'or' to create complex conditions.

Example: int score = 85; if (score is >= 80 and < 90) { Console.WriteLine("B grade"); } else { Console.WriteLine("Other grade"); } This checks if score is between 80 (inclusive) and 90 (exclusive).

Result

The program prints 'B grade' because 85 fits the condition.

Knowing how to combine relational patterns lets you express ranges and multiple conditions clearly in one place.

5

Advanced

Relational patterns with nullable types

🤔Before reading on: do relational patterns work directly on nullable types like int?? Commit to your answer.

Concept: Relational patterns can be used with nullable types, but you must handle null values carefully to avoid errors.

Example: int? temperature = null; if (temperature is not null and > 30) { Console.WriteLine("Hot day"); } else { Console.WriteLine("Not hot or unknown"); } This checks that temperature is not null and greater than 30.

Result

The program prints 'Not hot or unknown' because temperature is null.

Understanding how relational patterns interact with nullable types helps prevent runtime errors and makes your code safer.

6

Expert

Compiler optimization of relational patterns

🤔Before reading on: do you think relational patterns generate multiple comparisons or a single efficient check? Commit to your answer.

Concept: The C# compiler optimizes relational patterns to generate efficient code, often using jump tables or range checks to minimize comparisons.

When you write multiple relational patterns in a switch, the compiler arranges them to avoid redundant checks. For example: switch (x) { case < 10: case >= 20: // ... break; } The compiler generates code that quickly decides which case matches without checking every condition one by one.

Result

Your program runs faster and uses less CPU when using relational patterns in switch statements.

Knowing that relational patterns are optimized under the hood encourages their use in performance-sensitive code.

Under the Hood

Relational patterns work by evaluating the comparison operator against the input value during pattern matching. The compiler translates these patterns into conditional branching instructions that check the value against the specified relational condition. In switch expressions, the compiler arranges these checks efficiently to minimize the number of comparisons, often using jump tables or range checks. Nullable types require additional null checks before applying the relational comparison to avoid exceptions.

Why designed this way?

Relational patterns were introduced to simplify and unify value comparisons inside pattern matching, reducing boilerplate code. Before, developers had to write explicit if-else chains, which were verbose and error-prone. The design balances expressiveness with performance by allowing the compiler to optimize comparisons. Alternatives like separate if statements were less readable and harder to maintain, so integrating relational checks into patterns was a natural evolution.

Input Value
   │
   ▼
┌───────────────┐
│ Pattern Match │
│ Engine        │
└───────────────┘
   │
   ▼
┌───────────────┐
│ Check null?   │
│ (if nullable) │
└───────────────┘
   │
   ▼
┌───────────────┐
│ Evaluate      │
│ Relational    │
│ Operator      │
└───────────────┘
   │
   ▼
┌───────────────┐
│ Branch to     │
│ Matching Case │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 'case < 10' in a switch statement only match integers less than 10, or can it match other types too? Commit to your answer.

Common Belief: Relational patterns like 'case < 10' can match any type, not just numbers.

Reality: Relational patterns only work with types that support the comparison operators, typically numeric or comparable types. Using them with unsupported types causes compile errors.

Why it matters: Assuming relational patterns work on all types can lead to confusing compiler errors and wasted time debugging.

Quick: If you write 'case > 5 and < 10', does the order of conditions matter? Commit to your answer.

Common Belief: The order of relational conditions combined with 'and' or 'or' does not affect the result.

Reality: While logically the order does not change the meaning, the compiler evaluates conditions in the order written, which can affect performance if one condition is more expensive.

Why it matters: Ignoring evaluation order can cause subtle performance issues in critical code.

Quick: Can relational patterns be used to check for null values directly? Commit to your answer.

Common Belief: You can write 'case < null' or 'case > null' to check for null values.

Reality: Relational patterns cannot compare to null directly because null is not a value that supports ordering. Null checks must be done separately using 'is null' or 'is not null'.

Why it matters: Trying to compare null with relational patterns causes compile errors and confusion.

Quick: Does using relational patterns always make code faster than if-else statements? Commit to your answer.

Common Belief: Relational patterns always produce faster code than traditional if-else chains.

Reality: While relational patterns often lead to cleaner code, performance depends on compiler optimizations and context. Sometimes simple if-else can be equally fast or faster.

Why it matters: Assuming relational patterns are always faster can lead to premature optimization or misuse.

Expert Zone

1

Relational patterns can be combined with property patterns to match complex objects based on their properties' values.

2

The compiler may reorder relational patterns internally to optimize jump instructions, which can affect debugging and stack traces.

3

When using relational patterns with floating-point numbers, be aware of precision and rounding issues that can affect pattern matching.

When NOT to use

Avoid relational patterns when working with types that do not support ordering or when null handling is complex; use explicit if-else checks or custom methods instead. Also, for very complex conditions involving multiple unrelated properties, consider using full boolean expressions or separate methods for clarity.

Production Patterns

In production, relational patterns are often used in input validation, range checking, and state machines to simplify code. For example, validating user age ranges or categorizing sensor readings by thresholds uses relational patterns inside switch expressions or if statements for clean and maintainable code.

Connections

Finite State Machines

Relational patterns help define state transitions based on value ranges, which is a core part of finite state machines.

Understanding relational patterns clarifies how conditions trigger state changes in systems modeled by finite state machines.

Mathematical Inequalities

Relational patterns directly express inequalities like less than or greater than, mirroring mathematical notation.

Knowing math inequalities helps you intuitively grasp how relational patterns filter values in code.

Decision Trees (Machine Learning)

Relational patterns resemble decision tree splits where data is divided based on value comparisons.

Recognizing this connection helps understand how code conditions and machine learning models both segment data by value ranges.

Common Pitfalls

#1 Using relational patterns on types that don't support comparison.

Wrong approach:

object obj = "hello";
switch (obj)
{
case < "m":
Console.WriteLine("Before m");
break;
}

Correct approach:

string str = "hello";
switch (str)
{
case < "m":
Console.WriteLine("Before m");
break;
}

Root cause:

Relational patterns require the type to support comparison operators; 'object' does not, so casting or using the correct type is necessary.

#2 Trying to compare null with relational patterns.

Wrong approach:

int? value = null;
switch (value)
{
case < null:
Console.WriteLine("Less than null");
break;
}

Correct approach:

int? value = null;
switch (value)
{
case null:
Console.WriteLine("Value is null");
break;
case < 10:
Console.WriteLine("Less than 10");
break;
}

Root cause:

Null is not a comparable value; relational patterns cannot be used to check for null directly.

#3 Misordering combined relational patterns causing unexpected behavior.

Wrong approach:

int score = 85;
if (score is < 90 and >= 80)
{
Console.WriteLine("B grade");
}

Correct approach:

int score = 85;
if (score is >= 80 and < 90)
{
Console.WriteLine("B grade");
}

Root cause:

While logically equivalent, the order affects evaluation and readability; placing the lower bound first is clearer and can be more efficient.

Key Takeaways

Relational patterns let you write clear and concise comparisons inside pattern matching expressions.

They simplify code by replacing complex if-else chains with readable switch cases or conditions.

Relational patterns only work with types that support comparison operators and require careful handling of null values.

Combining relational patterns with logical patterns allows expressing complex range checks in a single expression.

The C# compiler optimizes relational patterns for performance, making them suitable for production use.