Pattern Matching in C#

🔍 Pattern Matching in C#

Pattern Matching is a feature in C# that allows you to test an object against a pattern and extract data from it in a concise and readable way. It simplifies conditional logic and enhances code clarity.

🧩 Types of Patterns

• Type Pattern: Checks if an object is of a specific type.
• Constant Pattern: Compares a value to a constant.
• Relational Pattern: Uses relational operators like >, <, ==.
• Property Pattern: Matches based on object properties.
• Positional Pattern: Matches deconstructed values or tuples.
• Var Pattern: Always matches and assigns the value to a variable.

💡 Example: Property Pattern

  public class Person {
      public string Name { get; set; }
      public int Age { get; set; }
  }

  Person person = new Person { Name = "Alice", Age = 25 };

  if (person is { Age: > 18 }) {
      Console.WriteLine("Adult");
  }
  

✅ Best Practices

• Use pattern matching to simplify type checks and null checks.
• Prefer switch expressions for clean branching logic.
• Use property patterns to match nested object structures.
• Avoid overly complex patterns that reduce readability.
• Combine patterns with is and switch for expressive logic.

📌 When to Use

• When checking types and extracting values in one step.
• For replacing verbose if-else or switch statements.
• In data-driven logic where object shape matters.
• When working with tuples or deconstructed types.

🚫 When Not to Use

• In performance-critical code where pattern matching may introduce overhead.
• When logic becomes too nested or hard to read.
• For simple equality checks where traditional comparisons are clearer.

⚠️ Precautions

• Ensure patterns are exhaustive to avoid unexpected behavior.
• Be cautious with null values—use is not null checks.
• Understand how reference vs value types behave in patterns.
• Test edge cases, especially with switch expressions.

🎯 Advantages of Pattern Matching

• Concise syntax: Reduces boilerplate code.
• Improved readability: Expresses intent clearly.
• Safe type casting: Eliminates manual casting.
• Flexible logic: Supports complex matching scenarios.
• Modern design: Aligns with functional programming styles.

📝 Conclusion

Pattern Matching in C# is a powerful tool for writing expressive, readable, and safe code. Use it to simplify logic, reduce boilerplate, and enhance maintainability—especially when working with complex data structures.