C# Type Pattern

​

Syntax

// Type pattern in a switch context (C# 9.0+)
case Type:
Type =>

// Type pattern combined within a logical pattern
expression is Type and [pattern]

// Declaration pattern (Type pattern + variable declaration)
expression is Type variableName

​

Mechanics and Evaluation Rules

• Type Compatibility: The pattern evaluates to true if the runtime type of the expression is exactly the target type, derives from the target type, or implements the target interface. Unlike the as operator, which only works with reference types and nullable value types, type patterns natively handle unboxing conversions for non-nullable value types.
• Null Safety: An expression that evaluates to null will strictly evaluate to false against any type pattern. Type patterns inherently guarantee that the matched expression is not null.
• Nullable Value Types: Nullable value types (T?) are strictly prohibited from being used as target types in patterns. Attempting to use a nullable value type in a pattern (e.g., obj switch { int? => ... } or expression is int? variableName) results in compiler error CS8116. Pattern matching evaluates the dynamic type of references or boxed values. While Nullable<T> is a standard, unboxed struct on the stack, boxing it invokes specific CLR behavior: it is never boxed as a Nullable<T>. Instead, it either becomes a null reference (if HasValue is false) or is boxed as the underlying non-nullable type T (if HasValue is true). To match a boxed nullable value type, the pattern must use the underlying type T.
• Definite Assignment: When a variable is declared within a declaration pattern, C#‘s compiler flow analysis ensures the variable is only considered “definitely assigned” in code paths where the pattern explicitly evaluated to true.

​

Structural Implementations

object obj = 42;

// Declaration pattern: Evaluates type and binds to 'i'
if (obj is int i)
{
    // 'i' is definitely assigned and strongly typed as int in this scope
    Console.WriteLine(i * 2);
}

// Type pattern: Evaluates type compatibility within a logical pattern (C# 9.0+)
if (obj is int and not 0)
{
    // Executes if obj is an unboxed integer that is not zero
}

object data = "System String";

switch (data)
{
    case int i:
        // Declaration pattern: Matches if data is an unboxed int, binds to 'i'
        break;
    case IEnumerable<string> list:
        // Declaration pattern: Matches if data implements IEnumerable<string>, binds to 'list'
        break;
    case string:
        // Type pattern: Matches string, no variable binding (C# 9.0+)
        break;
}

object input = 5.5;

Type resultType = input switch
{
    int _ => typeof(int),       // Declaration pattern using a discard for the variable name
    double d => typeof(double), // Declaration pattern with variable binding
    string => typeof(string),   // Type pattern (C# 9.0+)
    _ => typeof(object)         // Discard pattern
};