Why pattern matching matters in C Sharp (C#) - Why It Works This Way

Overview - Why pattern matching matters

What is it?

Pattern matching is a way to check data against a shape or condition and then do something based on that. It helps you write clearer and shorter code by directly working with the form of your data. Instead of many if-else checks, you can match patterns and extract values easily. This makes your programs easier to read and less error-prone.

Why it matters

Without pattern matching, programmers write long, complex code to check data types and values, which is hard to read and maintain. Pattern matching solves this by letting you express these checks naturally and safely. This saves time, reduces bugs, and makes your code more understandable, especially as programs grow bigger and handle many data shapes.

Where it fits

Before learning pattern matching, you should know basic C# syntax, variables, conditionals (if-else), and types. After mastering pattern matching, you can explore advanced topics like switch expressions, records, and functional programming styles in C#.

Mental Model

Core Idea

Pattern matching lets you check and extract data by its shape or type in a clear, concise way.

Think of it like...

It's like sorting mail by looking at the envelope's shape and address, then opening only the ones you need without checking every detail manually.

Data input
  │
  ▼
┌───────────────┐
│ Pattern Match │───► Matches shape/type? ──► Yes: Extract data and act
└───────────────┘           │
                            ▼
                          No: Try next pattern or default action

Build-Up - 6 Steps

1

Foundation

Understanding basic type checks

Concept: Learn how to check an object's type using simple if statements.

In C#, you can check if a variable is a certain type using the 'is' keyword. Example: object obj = 5; if (obj is int) { Console.WriteLine("It's an integer."); }

Result

Output: It's an integer.

Knowing how to check types manually is the base that pattern matching improves upon by making these checks simpler and safer.

2

Foundation

Extracting values with type checks

Concept: Learn how to check a type and get the value in one step using 'is' with a variable.

You can write: if (obj is int number) { Console.WriteLine($"Number is {number}"); } This checks if obj is int and assigns it to 'number' if true.

Result

Output: Number is 5

Combining type check and extraction reduces code and avoids repeated casts, making code safer and clearer.

3

Intermediate

Using switch with pattern matching

🤔Before reading on: do you think switch can only match exact values or can it match types and conditions too? Commit to your answer.

Concept: Switch statements can match patterns like types and conditions, not just exact values.

Example: object obj = 3.14; switch (obj) { case int i: Console.WriteLine($"Integer {i}"); break; case double d when d > 3: Console.WriteLine($"Double greater than 3: {d}"); break; default: Console.WriteLine("Other type"); break; }

Result

Output: Double greater than 3: 3.14

Switch with patterns lets you handle many cases cleanly, combining type and condition checks in one place.

4

Intermediate

Simplifying code with switch expressions

🤔Before reading on: do you think switch expressions can return values directly or only execute statements? Commit to your answer.

Concept: Switch expressions return values directly, making code concise and expressive.

Example: object obj = "hello"; string result = obj switch { int i => $"Int {i}", string s => $"String '{s}'", _ => "Unknown" }; Console.WriteLine(result);

Result

Output: String 'hello'

Switch expressions reduce boilerplate and make your intent clearer by directly producing results from patterns.

5

Advanced

Deconstructing data with patterns

🤔Before reading on: do you think pattern matching can work inside custom objects to extract parts? Commit to your answer.

Concept: Pattern matching can extract parts of custom objects using deconstruction patterns.

Example with a Point record: record Point(int X, int Y); Point p = new(3, 4); if (p is Point(var x, var y)) { Console.WriteLine($"X={x}, Y={y}"); }

Result

Output: X=3, Y=4

Deconstruction patterns let you work with complex data structures naturally, improving code clarity and reducing manual extraction.

6

Expert

Combining patterns for powerful matching

🤔Before reading on: do you think you can combine multiple pattern types like type, property, and relational in one match? Commit to your answer.

Concept: You can combine different pattern types to create precise and powerful matches.

Example: object obj = new Point(5, 10); string description = obj switch { Point { X: > 0, Y: > 0 } p => $"Point in first quadrant: {p}", Point p => $"Point elsewhere: {p}", _ => "Not a point" }; Console.WriteLine(description);

Result

Output: Point in first quadrant: Point { X = 5, Y = 10 }

Combining patterns allows you to express complex logic clearly and safely, reducing bugs and improving maintainability.

Under the Hood

Pattern matching in C# is implemented by the compiler generating code that tests the input against each pattern in order. It uses type checks, property getters, and conditional tests to decide if a pattern matches. When a match occurs, it extracts values into variables. This process is optimized to avoid unnecessary checks and casts, making it efficient at runtime.

Why designed this way?

Pattern matching was introduced to replace verbose and error-prone manual type checks and casts. It was designed to integrate smoothly with existing C# features like switch and records, allowing gradual adoption. The design balances expressiveness with performance and readability, avoiding complex syntax while enabling powerful matching.

Input data
   │
   ▼
┌───────────────┐
│ Pattern List  │
│ ┌───────────┐ │
│ │ Pattern 1 │─┼─► Check type, properties, conditions
│ └───────────┘ │
│ ┌───────────┐ │
│ │ Pattern 2 │─┼─► If no match, try next
│ └───────────┘ │
│     ...       │
└───────────────┘
   │
   ▼
Match found? ──► Yes: Extract variables and run code
                No: Run default or error

Myth Busters - 4 Common Misconceptions

Quick: Does pattern matching only check types, or can it also check values and conditions? Commit to your answer.

Common Belief: Pattern matching only checks the type of a variable, nothing more.

Reality: Pattern matching can check types, values, properties, and even conditions like greater than or less than.

Why it matters: Believing this limits how you use pattern matching and causes you to write more complex code with manual checks.

Quick: Is pattern matching slower than traditional if-else checks? Commit to your answer.

Common Belief: Pattern matching is slower because it adds overhead with complex checks.

Reality: Pattern matching is optimized by the compiler and often as fast or faster than manual checks.

Why it matters: Avoiding pattern matching due to performance fears can lead to less readable and more error-prone code.

Quick: Can pattern matching only be used with simple types like int or string? Commit to your answer.

Common Belief: Pattern matching only works with simple built-in types.

Reality: Pattern matching works with complex types, including custom classes and records, using deconstruction and property patterns.

Why it matters: Missing this means you don't leverage pattern matching's full power in real-world applications.

Quick: Does pattern matching replace all if-else statements? Commit to your answer.

Common Belief: Pattern matching can replace every if-else and switch statement.

Reality: Pattern matching is powerful but not always the best choice; some logic is clearer with simple if-else or polymorphism.

Why it matters: Overusing pattern matching can make code harder to understand or maintain in some cases.

Expert Zone

1

Pattern matching order matters: later patterns are only checked if earlier ones fail, so arrange from most specific to general.

2

Combining patterns with logical operators (and, or, not) allows very precise matches but can reduce readability if overused.

3

Compiler optimizations can transform pattern matching into jump tables or decision trees for performance, but complex patterns may still have overhead.

When NOT to use

Avoid pattern matching when simple polymorphism or virtual methods express the logic more naturally. Also, for very simple checks, if-else may be clearer. When performance is critical and patterns are complex, manual optimization might be better.

Production Patterns

In real-world C# code, pattern matching is used in parsing input data, handling different message types, simplifying validation logic, and working with immutable data via records. It often appears in switch expressions for concise result mapping and in combination with LINQ for filtering.

Connections

Functional Programming

Pattern matching builds on the same idea of matching data shapes common in functional languages.

Understanding pattern matching in C# helps grasp functional programming concepts like algebraic data types and immutability.

Polymorphism

Pattern matching can sometimes replace polymorphism by checking types explicitly instead of using virtual methods.

Knowing when to use pattern matching versus polymorphism improves design decisions and code clarity.

Human Pattern Recognition

Both involve recognizing shapes and features to make decisions quickly.

Studying how humans spot patterns can inspire better ways to write and understand pattern matching in code.

Common Pitfalls

#1 Checking patterns in the wrong order causing unexpected matches.

Wrong approach:

switch (obj) {
case object _:
Console.WriteLine("Any object");
break;
case int i:
Console.WriteLine($"Int {i}");
break;
}

Correct approach:

switch (obj) {
case int i:
Console.WriteLine($"Int {i}");
break;
case object _:
Console.WriteLine("Any object");
break;
}

Root cause:

Patterns are checked top to bottom; a general pattern first blocks more specific ones below.

#2 Using pattern matching without extracting variables when needed.

Wrong approach:

if (obj is int) {
Console.WriteLine(obj + 1);
}

Correct approach:

if (obj is int number) {
Console.WriteLine(number + 1);
}

Root cause:

Not extracting the matched value forces unsafe casts or errors.

#3 Overusing complex combined patterns making code hard to read.

Wrong approach:

if (obj is Point { X: > 0 and < 10, Y: > 0 and < 10 } p && p.X + p.Y > 10) {
// complex logic
}

Correct approach:

if (obj is Point p && p.X > 0 && p.X < 10 && p.Y > 0 && p.Y < 10 && p.X + p.Y > 10) {
// clearer logic
}

Root cause:

Trying to do too much in one pattern reduces readability and maintainability.

Key Takeaways

Pattern matching lets you check data types and shapes clearly and safely in C#.

It reduces boilerplate code by combining checks and value extraction in one step.

Switch expressions with pattern matching make code concise and expressive.

Combining different pattern types unlocks powerful and precise data handling.

Understanding pattern matching improves code readability, safety, and maintainability.

Practice

1. What is the main benefit of using pattern matching in C#?

easy

A. It simplifies checking types and extracting data in one step.

B. It makes the program run faster by optimizing CPU usage.

C. It automatically fixes syntax errors in the code.

D. It replaces all loops with recursive calls.

Solution

1. Step 1: Understand pattern matching purpose

   Pattern matching lets you check a variable's type and extract its data in a single, clear step.

2. Step 2: Compare with other options

   Options A, B, and D describe unrelated or incorrect benefits not provided by pattern matching.

3. Final Answer:

   It simplifies checking types and extracting data in one step. -> Option A

4. Quick Check:

   Pattern matching = Simplifies type checks [OK]

Hint: Pattern matching combines type check and data use in one step [OK]

Common Mistakes:

• Thinking pattern matching speeds up CPU performance
• Confusing pattern matching with syntax error fixing
• Believing pattern matching replaces loops

2. Which of the following is the correct syntax for pattern matching with is in C#?

easy

A. if (obj is int number) { /* use number */ }

B. if (obj is int) number { /* use number */ }

C. if (obj is int: number) { /* use number */ }

D. if (obj int is number) { /* use number */ }

Solution

1. Step 1: Recall correct pattern matching syntax

   The correct syntax uses is Type variable inside the if condition, like obj is int number.

2. Step 2: Identify syntax errors in other options

   Options A, B, and C have incorrect order or punctuation that cause syntax errors.

3. Final Answer:

   if (obj is int number) { /* use number */ } -> Option A

4. Quick Check:

   Correct pattern matching syntax = if (obj is int number) { /* use number */ } [OK]

Hint: Remember: 'is Type variable' is the pattern matching syntax [OK]

Common Mistakes:

• Placing variable before type in 'is' expression
• Using colon ':' instead of space
• Mixing order of keywords

3. What will be the output of this code?

object obj = 42;
switch (obj)
{
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    case string s:
        Console.WriteLine($"String: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}

medium

A. String: 42

B. Integer: 42

C. Unknown type

D. Compilation error

Solution

1. Step 1: Identify the type of obj

   obj is assigned the integer value 42, so its runtime type is int.

2. Step 2: Match switch cases

   The switch matches case int i because obj is an int, so it prints "Integer: 42".

3. Final Answer:

   Integer: 42 -> Option B

4. Quick Check:

   obj is int 42, so output = "Integer: 42" [OK]

Hint: Match the runtime type to the correct case in switch [OK]

Common Mistakes:

• Assuming obj is string because of quotes missing
• Thinking default case runs first
• Confusing compile-time and runtime types

4. Identify the error in this pattern matching code:

object obj = "hello";
if (obj is int number)
{
    Console.WriteLine(number);
}

medium

A. The variable 'number' is not declared before use.

B. The 'is' keyword cannot be used with variables.

C. Missing braces around the if block.

D. The pattern matching condition will never be true for a string.

Solution

1. Step 1: Analyze the type of obj

   obj holds a string "hello", but the pattern checks if obj is an int.

2. Step 2: Understand pattern matching behavior

   Since obj is a string, the condition obj is int number is false, so the block never runs.

3. Final Answer:

   The pattern matching condition will never be true for a string. -> Option D

4. Quick Check:

   obj is string, pattern checks int, so condition false [OK]

Hint: Check if variable type matches pattern type before using it [OK]

Common Mistakes:

• Assuming variable 'number' must be declared separately
• Thinking 'is' cannot be used with variables
• Ignoring that condition can be false without error

5. Given a list of objects List<object> items = new() { 1, -2, "two", 3.0, null };, which pattern matching expression correctly counts only the positive integer values?

hard

A. items.Count(item => item is string s)

B. items.Count(item => item is int)

C. items.Count(item => item is int number && number > 0)

D. items.Count(item => item != null)

Solution

1. Step 1: Understand the goal

   We want to count only positive integers in the list, ignoring other types and null.

2. Step 2: Analyze each option

   items.Count(item => item is int) counts all ints but does not filter by value; items.Count(item => item is int number && number > 0) counts ints greater than 0, which matches positive integers; items.Count(item => item is string s) counts strings; items.Count(item => item != null) counts all non-null items.

3. Step 3: Choose the best option

   items.Count(item => item is int number && number > 0) uses pattern matching with a condition to count only positive integers, which is a precise use of pattern matching.

4. Final Answer:

   items.Count(item => item is int number && number > 0) -> Option C

5. Quick Check:

   Pattern matching with condition filters integers correctly [OK]

Hint: Use 'is Type var && condition' to filter precisely [OK]

Common Mistakes:

• Counting all ints without condition when needed
• Counting strings or non-null items by mistake
• Not using variable in pattern matching for conditions