Type checking patterns in C Sharp (C#) - Deep Dive

Overview - Type checking patterns

What is it?

Type checking patterns in C# let you test an object's type and extract information from it in a simple, readable way. Instead of writing long if-else statements, you use patterns to check types and get values in one step. This makes your code cleaner and easier to understand. It works with variables, properties, and even complex conditions.

Why it matters

Without type checking patterns, programmers write repetitive and error-prone code to check types and cast objects. This slows development and makes code harder to maintain. Type checking patterns solve this by combining type tests and value extraction, reducing bugs and improving readability. This helps build safer and more efficient programs that handle different data types smoothly.

Where it fits

Before learning type checking patterns, you should understand basic C# types, variables, and conditional statements. Knowing about casting and the 'is' keyword helps too. After mastering this, you can explore advanced pattern matching, switch expressions, and nullable reference types to write even more expressive code.

Mental Model

Core Idea

Type checking patterns let you check an object's type and extract its value in one clear step, making your code simpler and safer.

Think of it like...

It's like checking the shape of a box and opening it at the same time to see what's inside, instead of first guessing the shape and then opening it separately.

Object
  │
  ├─ Is it Type A? ── Yes ── Extract value as Type A
  │                      │
  │                      No
  │
  ├─ Is it Type B? ── Yes ── Extract value as Type B
  │                      │
  │                      No
  │
  └─ Default action

Build-Up - 7 Steps

1

Foundation

Understanding basic type checks

Concept: Learn how to check an object's type using the 'is' keyword.

In C#, you can check if an object is a certain type using 'is'. For example: object obj = 5; if (obj is int) { Console.WriteLine("It's an int!"); } This checks if obj is an integer.

Result

Output: It's an int!

Understanding the 'is' keyword is the foundation for all type checking patterns because it tells you if an object matches a type.

2

Foundation

Casting after type check

Concept: Learn how to cast an object to a type after checking its type.

After checking the type, you often need to convert the object to that type: object obj = 5; if (obj is int) { int number = (int)obj; // cast Console.WriteLine(number + 10); } This prints 15.

Result

Output: 15

Casting after type check is common but can be verbose and error-prone if done repeatedly.

3

Intermediate

Using pattern matching with 'is' keyword

🤔Before reading on: do you think 'is' can both check type and assign a variable in one step? Commit to yes or no.

Concept: Learn how 'is' can check type and assign a variable simultaneously using pattern matching.

C# lets you combine type check and assignment: object obj = 5; if (obj is int number) { Console.WriteLine(number + 10); } Here, 'number' is assigned only if obj is int.

Result

Output: 15

Knowing that 'is' can assign variables while checking type reduces code and avoids redundant casts.

4

Intermediate

Using 'switch' with type patterns

🤔Before reading on: can a switch statement match types directly? Commit to yes or no.

Concept: Learn how to use switch statements to match types and execute code accordingly.

You can write: object obj = 3.14; switch (obj) { case int i: Console.WriteLine($"Integer {i}"); break; case double d: Console.WriteLine($"Double {d}"); break; default: Console.WriteLine("Unknown type"); break; } This prints 'Double 3.14'.

Result

Output: Double 3.14

Switch with type patterns makes branching by type clearer and more maintainable than nested if-else.

5

Intermediate

Using relational and logical patterns

🤔Before reading on: do you think type patterns can combine with conditions like 'and' or 'or'? Commit to yes or no.

Concept: Learn how to combine type checks with extra conditions using 'and' (&&) and 'or' (||) patterns.

Example: object obj = 10; if (obj is int number && number > 5) { Console.WriteLine("Number is greater than 5"); } This prints the message only if obj is int and > 5.

Result

Output: Number is greater than 5

Combining type and value conditions in one pattern makes code concise and expressive.

6

Advanced

Using 'not' and discard patterns

🤔Before reading on: can you exclude a type using patterns? Commit to yes or no.

Concept: Learn how to exclude types with 'not' and ignore values with discard (_) patterns.

Example: object obj = "hello"; if (obj is not int) { Console.WriteLine("Not an int"); } Also, discard pattern: if (obj is int _) { Console.WriteLine("It's an int, but we don't need the value"); } The underscore means we don't care about the value.

Result

Output: Not an int

Excluding types and ignoring values help write clearer intent and avoid unnecessary variables.

7

Expert

Pattern matching performance and pitfalls

🤔Before reading on: do you think all pattern matches have the same speed? Commit to yes or no.

Concept: Understand how pattern matching compiles and its performance implications, including common mistakes.

Pattern matching compiles into efficient code but complex patterns can cause multiple type checks or casts. For example, overlapping patterns in switch can cause unexpected matches. Also, beware of null values when matching reference types. Example pitfall: object obj = null; switch (obj) { case string s: Console.WriteLine("String"); break; case null: Console.WriteLine("Null"); break; } Here, null case must be last to avoid errors.

Result

Output: Null

Knowing how patterns compile helps avoid subtle bugs and write performant, correct code.

Under the Hood

At runtime, type checking patterns use the Common Language Runtime's type system to test an object's actual type. The compiler generates code that first checks the object's type and then, if matched, casts it to the target type and assigns it to a new variable. Complex patterns combine these checks with logical operations, short-circuiting when possible. This reduces redundant casts and improves performance compared to manual checks.

Why designed this way?

C# introduced pattern matching to simplify and unify type checks and casts, which were verbose and error-prone. The design balances readability and performance by integrating with existing language features like 'is' and 'switch'. Alternatives like separate type checks and casts were less readable and more bug-prone, so pattern matching was chosen to improve developer productivity and code safety.

┌───────────────┐
│   Object obj  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Type check by │
│ pattern match │
└──────┬────────┘
       │ yes
       ▼
┌───────────────┐
│ Cast and bind │
│ to variable   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Use variable  │
│ in code       │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 'obj is int number' always create a new variable 'number' even if the check fails? Commit yes or no.

Common Belief: People think the variable is created regardless of the type check result.

Reality: The variable is only created and assigned if the type check succeeds; otherwise, it doesn't exist in that scope.

Why it matters: Assuming the variable always exists can cause compile errors or runtime bugs when accessing it outside the if block.

Quick: Can pattern matching replace all type casts safely? Commit yes or no.

Common Belief: Some believe pattern matching can replace every cast without issues.

Reality: Pattern matching is safer but only works when you want to check and use the type immediately; some casts require explicit conversion or handling.

Why it matters: Misusing pattern matching instead of proper casts can cause logic errors or missed exceptions.

Quick: Does the order of cases in a switch with type patterns not affect which case runs? Commit yes or no.

Common Belief: Many think switch cases are independent and order doesn't matter.

Reality: Switch cases are checked in order; the first matching case runs, so order affects behavior.

Why it matters: Wrong order can cause unexpected matches and bugs, especially with overlapping types.

Quick: Is pattern matching always slower than traditional type checks? Commit yes or no.

Common Belief: Some assume pattern matching adds overhead and is slower.

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

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

Expert Zone

1

Pattern matching variables have limited scope only within the true branch, preventing accidental misuse outside.

2

Combining patterns with relational and logical operators allows very expressive and concise conditions that replace nested ifs.

3

Switch expressions with type patterns enable functional-style code that returns values directly, improving readability.

When NOT to use

Avoid pattern matching when you need to perform complex conversions or when the type hierarchy is very deep and performance is critical; explicit casts or polymorphism might be better. Also, for very simple type checks without value extraction, classic 'is' or 'as' might be clearer.

Production Patterns

In real-world C# code, type checking patterns are used in parsing, serialization, and UI event handling to safely extract data. They appear in switch expressions for concise logic and in combination with nullable types to handle optional data cleanly. Experts also use them to implement visitor patterns and polymorphic behavior without inheritance.

Connections

Polymorphism

Type checking patterns complement polymorphism by allowing explicit type handling when virtual methods are insufficient.

Understanding type checking patterns helps know when to rely on polymorphism versus explicit type tests for clearer, safer code.

Functional programming

Switch expressions with type patterns bring functional style branching into C#.

Knowing pattern matching aids in writing concise, expression-based code similar to functional languages.

Biology - Species classification

Type checking is like classifying an animal by its species and then studying its traits.

Recognizing how we identify and extract traits in biology helps understand how type patterns identify and extract data in programming.

Common Pitfalls

#1 Using 'is' without variable assignment and then casting separately.

Wrong approach:

if (obj is int) {
int n = (int)obj;
Console.WriteLine(n);
}

Correct approach:

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

Root cause:

Not knowing that 'is' can assign variables leads to redundant and verbose code.

#2 Placing more general switch cases before specific ones causing unreachable code.

Wrong approach:

switch (obj) {
case object o:
Console.WriteLine("Any object");
break;
case string s:
Console.WriteLine("String");
break;
}

Correct approach:

switch (obj) {
case string s:
Console.WriteLine("String");
break;
case object o:
Console.WriteLine("Any object");
break;
}

Root cause:

Misunderstanding switch case order and pattern matching priority.

#3 Ignoring null values in pattern matching leading to NullReferenceException.

Wrong approach:

if (obj is string s && s.Length > 0) {
Console.WriteLine(s);
}

Correct approach:

if (obj is string s && s?.Length > 0) {
Console.WriteLine(s);
}

Root cause:

Not accounting for null when combining patterns with property access.

Key Takeaways

Type checking patterns combine type tests and value extraction in one clear step, making code simpler and safer.

The 'is' keyword with pattern matching lets you check type and assign variables simultaneously, reducing redundant casts.

Switch statements with type patterns provide a clean way to branch logic based on object types.

Combining type patterns with logical conditions allows expressive and concise code.

Understanding pattern matching internals helps avoid subtle bugs and write efficient, maintainable programs.