Elegant Multi-Value Matching in C#: From Traditional If Statements to Modern Syntax Extensions

Traditional Implementation and Limitations of Multi-Value Conditionals

In C# programming practice, developers frequently encounter scenarios where they need to check whether a variable equals one of several possible values. The traditional approach uses logical OR operators to connect multiple equality comparisons:

if (value == 1 || value == 2 || value == 3)
{
    // Processing logic
}

While this method is straightforward, as the number of comparison values increases, the code becomes verbose and difficult to maintain. Particularly when dealing with five or more values, code readability significantly decreases, and errors may occur due to missing parentheses or logical operators.

Collection-Based Solutions

Inspired by the IN clause in SQL, C# developers can achieve similar functionality through collection operations. The most direct approach uses the array Contains method:

if (new[] {1, 2, 3}.Contains(value))
{
    // Processing logic
}

The advantages of this method include:

• Concise syntax with clear intent
• Support for any basic type (int, string, etc.)
• Easy extensibility - adding new values only requires modifying array initialization

However, each call creates a new array instance, which may cause unnecessary overhead in performance-sensitive scenarios. For fixed value collections, defining them as static members can avoid repeated allocations:

private static readonly int[] ValidValues = {1, 2, 3};

if (ValidValues.Contains(value))
{
    // Processing logic
}

Elegant Implementation with Custom Extension Methods

To achieve more natural syntax, developers can create custom extension methods. This approach encapsulates multi-value checking into type-safe generic methods:

public static bool In<T>(this T obj, params T[] args)
{
    if (args == null) throw new ArgumentNullException(nameof(args));
    return args.Contains(obj);
}

The extension method offers intuitive usage patterns:

// Integer type
if (value.In(1, 2, 3))
{
    // Processing logic
}

// String type
if (status.In("active", "pending", "approved"))
{
    // Processing logic
}

// Even direct literal usage
if (5.In(1, 3, 5, 7, 9))
{
    Console.WriteLine("5 is an odd number");
}

This implementation provides several benefits:

1. Type Safety: Generic parameters ensure type consistency
2. Parameter Flexibility: params keyword supports variable number of arguments
3. Enhanced Readability: Method name In clearly expresses intent
4. Extensibility: Easy to add overloaded versions supporting IEnumerable<T>

A more complete implementation might include null checking and performance optimizations:

public static bool In<T>(this T obj, params T[] args)
{
    if (args == null || args.Length == 0)
        return false;
    
    // For small arrays, linear search is typically efficient enough
    for (int i = 0; i < args.Length; i++)
    {
        if (EqualityComparer<T>.Default.Equals(obj, args[i]))
            return true;
    }
    return false;
}

Pattern Matching Syntax in C# 9 and Beyond

C# 9 introduced more concise pattern matching syntax that directly supports multi-value comparisons:

if (value is 1 or 2 or 3)
{
    // Processing logic
}

This syntax compiles to traditional logical OR expressions, offering identical performance to direct || operator usage. However, it primarily applies to constant pattern matching, with limited support for variables or complex expressions.

Performance Considerations and Best Practices

When selecting a multi-value matching approach, consider the following factors:

For most application scenarios, custom extension methods provide the best balance: good readability, adequate performance, and maximum flexibility. Particularly in team development environments, a unified In method can significantly improve code consistency.

Advanced Applications and Extensions

Building upon the core In method, developers can extend functionality further:

// Overload supporting IEnumerable<T>
public static bool In<T>(this T obj, IEnumerable<T> collection)
{
    if (collection == null) throw new ArgumentNullException(nameof(collection));
    return collection.Contains(obj);
}

// Version supporting custom comparers
public static bool In<T>(this T obj, IEqualityComparer<T> comparer, params T[] args)
{
    if (args == null) throw new ArgumentNullException(nameof(args));
    if (comparer == null) comparer = EqualityComparer<T>.Default;
    
    for (int i = 0; i < args.Length; i++)
    {
        if (comparer.Equals(obj, args[i]))
            return true;
    }
    return false;
}

// Usage example: case-insensitive string comparison
if (input.In(StringComparer.OrdinalIgnoreCase, "YES", "Y", "OK"))
{
    // Process affirmative responses
}

These extensions enable the In method to accommodate more complex business requirements while maintaining the simplicity of the core API.

Conclusion and Recommendations

C# offers multiple approaches for implementing multi-value matching, each with appropriate use cases. For new projects or those able to upgrade to the latest language version, C# 9's pattern matching syntax provides the most concise solution. For projects requiring backward compatibility or more flexible functionality, custom extension methods offer the optimal choice, balancing readability, performance, and flexibility effectively.

In practical development, teams should adopt a primary approach consistently and document it clearly in coding standards. For performance-critical paths, traditional || operators may still be considered. Regardless of the chosen approach, clear intent expression and consistent coding style remain more important than minor performance differences.