Enforce switch expression usage

irectly in the pattern. This is critical for parsing protocols or validating input arrays.

public string ParseResponse(Span<byte> payload) => payload switch
{
    [0x01, var status, ..] when status == 0x00 => "Success",
    [0x01, var status, ..] => $"Error: {status}",
    [0x02, var code, var message, .. var rest] => $"Data: {code} {message}",
    _ => "Unknown Protocol"
};

5. Relational and Property Patterns

Combine relational patterns with property patterns to filter data deeply without intermediate variables.

public string GetRiskLevel(Transaction tx) => tx switch
{
    { Amount: > 10000, Country: "XX" } => "Critical",
    { Amount: > 5000, Country: not "US" } => "High",
    { Amount: > 1000 } => "Medium",
    _ => "Low"
};

Pitfall Guide

Production experience reveals specific anti-patterns that degrade performance and maintainability. Avoid these common mistakes.

1. Using switch Statements Instead of Expressions:

   • Mistake: Using switch statements for control flow that returns values.
   • Impact: Increases verbosity, allows fall-through errors, and reduces compiler enforcement of exhaustiveness.
   • Fix: Always prefer switch expressions when mapping input to output.

2. Side Effects in when Clauses:

   • Mistake: Calling methods with side effects inside when guards.
   • Impact: when clauses may be evaluated multiple times or reordered by the compiler. Side effects lead to unpredictable behavior and race conditions.
   • Fix: when clauses must be pure functions. Extract side effects before the pattern match.

3. Over-Nesting Recursive Patterns:

   • Mistake: Creating deeply nested recursive patterns that span multiple lines and levels.
   • Impact: Reduces readability and makes debugging difficult. The compiler error messages become obscure.
   • Fix: Flatten patterns where possible. Extract complex sub-matches into helper methods or use logical patterns.

4. Pattern Matching on Mutable State:

   • Mistake: Matching against objects that change state during the evaluation of the pattern.
   • Impact: If a property changes between the check and the binding, the code may operate on inconsistent state.
   • Fix: Use pattern matching on immutable snapshots or records. If matching mutable objects, ensure thread safety or capture values immediately.

5. Ignoring the Discard _ in Exhaustive Checks:

   • Mistake: Omitting the discard case in a switch expression or using it to mask missing logic.
   • Impact: In switch expressions, omitting _ causes a compiler error if not all cases are covered (good). However, using _ to swallow unhandled cases in business logic hides bugs.
   • Fix: Use _ only when the default behavior is intentional. During development, throw NotImplementedException in the default case to ensure new types are handled.

6. Performance Anti-Pattern: Allocation in Patterns:

   • Mistake: Using patterns that trigger allocations, such as matching against IEnumerable without GetEnumerator optimization or using list patterns on large collections repeatedly.
   • Impact: List patterns on arrays are efficient, but on IEnumerable, they may enumerate multiple times.
   • Fix: Use Span<T> or arrays for list patterns in hot paths. Avoid enumerables in performance-critical matching.

7. Redundant Type Checks:

   • Mistake: Combining is checks with pattern matching unnecessarily.
   • Impact: if (obj is DerivedType dt && dt.Property > 0) is redundant if dt is only used in the condition.
   • Fix: Use property patterns directly: if (obj is DerivedType { Property: > 0 }).

Production Bundle

Action Checklist

• Audit as casts: Search codebase for as and replace with is patterns to eliminate null-check boilerplate.
• Migrate to Switch Expressions: Convert switch statements that return values to switch expressions to enforce exhaustiveness.
• Introduce C# 11 List Patterns: Refactor array/span validation logic to use list patterns for concise sequence matching.
• Adopt Records for Data Carriers: Convert POCOs used in pattern matching to record types to ensure immutability and value-based semantics.
• Purify when Clauses: Review all when clauses for side effects; refactor any mutations or I/O operations outside the pattern.
• Enable Roslyn Analyzers: Configure analyzers to warn on incomplete switch expressions and suggest pattern matching opportunities.
• Benchmark Hot Paths: Profile critical loops using pattern matching; ensure no hidden allocations occur in tight loops.

Decision Matrix

Configuration Template

Add this .editorconfig snippet to enforce pattern matching styles and enable relevant analyzers in your project.

# Enforce switch expression usage
dotnet_style_prefer_switch_expression = true:suggestion

# Prefer pattern matching over `as` checks
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion

# Enable exhaustive switch warnings
dotnet_analyzer_diagnostic.severity = warning

# C# Language Version
is_global = true
dotnet_build_property_langversion = 12

Quick Start Guide

1. Upgrade Language Version: Ensure your .csproj targets C# 12 or higher.

   <PropertyGroup>
       <TargetFramework>net8.0</TargetFramework>
       <LangVersion>12</LangVersion>
   </PropertyGroup>
   

2. Refactor a Candidate: Identify a method with nested if checks or a switch statement. Convert it to a switch expression using property and logical patterns.
3. Validate Exhaustiveness: Remove the default _ case temporarily. Let the compiler highlight missing cases. Add handling for each case.
4. Run Diagnostics: Execute dotnet build to verify analyzer warnings. Address any suggestions regarding pattern usage.
5. Benchmark: If the refactored code is in a hot path, run a benchmark comparing the old and new implementation to verify performance characteristics.

This guide provides the technical foundation for leveraging C# pattern matching in production environments. By adhering to these patterns and avoiding identified pitfalls, engineering teams can achieve significant gains in code safety, performance, and maintainability.