C# Relational Pattern

A relational pattern in C# is a pattern matching construct introduced in C# 9.0 that evaluates whether an expression satisfies a relational operator condition against a constant value. It extends the is operator and switch statements/expressions by allowing direct magnitude comparisons without requiring explicit variable declarations or complex if-else chains.

Syntax and Operators

A relational pattern consists of a relational operator followed by a constant expression. The supported operators are:

< (less than)
<= (less than or equal to)
> (greater than)
>= (greater than or equal to)

int expression = 42;

// Syntax within an 'is' expression
bool match = expression is > 0;

// Syntax within a switch expression
int result = expression switch
{
    < 0 => -1,
    > 0 => 1,
    _ => 0
};

Technical Constraints

Constant Right-Hand Side: The value on the right side of the relational operator must be a compile-time constant. You cannot use variables, method returns, or dynamically evaluated expressions as the target of the pattern.
Supported Types: Relational patterns are restricted to types that have built-in relational operators. This includes:
- All integral and floating-point numeric types (int, double, decimal, byte, nint, etc.)
- char
- enum types
Nullability: If the input expression is a nullable value type (e.g., int?), a relational pattern implicitly checks for null. A null value will safely fail the pattern match without throwing a NullReferenceException.

Code Mechanics

The following demonstrates the structural application of relational patterns across different C# constructs:

int numericValue = 42;

// 1. Evaluation via 'is' operator
bool isPositive = numericValue is > 0;

// 2. Evaluation within a switch statement
switch (numericValue)
{
    case < 0:
        Console.WriteLine("Negative");
        break;
    case >= 0:
        Console.WriteLine("Non-negative");
        break;
}

// 3. Evaluation within a switch expression
string magnitude = numericValue switch
{
    < 10 => "Single digit",
    >= 10 => "Multiple digits"
};

Composition with Logical Patterns

Relational patterns are strictly single-operator. To define bounded ranges, they must be composed using C# logical patterns (and, or, not). The compiler evaluates these composite patterns to ensure type safety and logical coherence.

int target = 25;

// Defining an inclusive range using the 'and' logical pattern
bool inRange = target is >= 10 and <= 50;

// Defining an exclusive boundary using the 'or' logical pattern
bool outOfBounds = target is < 0 or > 100;

Compiler Behavior: Subsumption and Exhaustiveness

When relational patterns are used within switch expressions, the C# compiler performs static analysis to verify two conditions:

Exhaustiveness: The compiler checks if all possible values of the input type are handled. If the relational patterns leave a gap (e.g., < 0 and > 0, leaving 0 unhandled) and no discard pattern (_) is provided, the compiler issues a warning (CS8509).
Subsumption (Unreachability): The compiler evaluates the order of relational patterns. If a broader pattern precedes a narrower pattern that it entirely overlaps, the compiler flags the narrower pattern as unreachable code (CS8510).

int value = 15;

string result = value switch
{
    < 20 => "Matched first",
    < 10 => "Unreachable", // Compiler Warning CS8510: The pattern is unreachable.
    _ => "Default"
};