Chaining comparison operators in C#

C# supports chaining comparison operators based on operator associativity and precedence. When multiple operators of the same precedence appear in an expression, they are evaluated according to their associativity rules, typically left-to-right.

Understanding how comparison operators chain together is crucial for writing correct conditional expressions and avoiding logical errors in your code.

Syntax

Following is the basic syntax for chaining comparison operators −

variable1 == variable2 == variable3
variable1 != variable2 != variable3

The evaluation follows left-to-right associativity −

(variable1 == variable2) == variable3

How Operator Chaining Works

Operator precedence determines the grouping of terms in an expression, affecting how the expression is evaluated. Operators with higher precedence are evaluated first. When operators have the same precedence, associativity rules determine the order of evaluation.

Equality operators (== and !=) have left-to-right associativity, meaning they are evaluated from left to right when chained together.

Example of Chained Equality Operators

using System;

class Program {
   public static void Main() {
      int a = 5, b = 5, c = 5;
      bool result1 = a == b == true;
      bool result2 = (a == b) == true;
      
      Console.WriteLine("a = " + a + ", b = " + b + ", c = " + c);
      Console.WriteLine("a == b == true: " + result1);
      Console.WriteLine("(a == b) == true: " + result2);
      
      // Demonstrating the evaluation order
      bool step1 = a == b;  // true
      bool step2 = step1 == true;  // true == true = true
      Console.WriteLine("Step by step: " + step1 + " == true = " + step2);
   }
}

The output of the above code is −

a = 5, b = 5, c = 5
a == b == true: True
(a == b) == true: True
Step by step: True == true = True

Common Use Case - Null Checking

A practical example of operator chaining is checking whether a string is null or not −

using System;

class Program {
   public static void Main() {
      string str1 = null;
      string str2 = "Hello";
      
      // This chains: (str1 == null) == false
      bool result1 = str1 == null == false;
      bool result2 = str2 == null == false;
      
      Console.WriteLine("str1 is null: " + (str1 == null));
      Console.WriteLine("str1 == null == false: " + result1);
      Console.WriteLine("str2 == null == false: " + result2);
      
      // Better approach for clarity
      bool isNotNull = str2 != null;
      Console.WriteLine("str2 != null: " + isNotNull);
   }
}

The output of the above code is −

str1 is null: True
str1 == null == false: False
str2 == null == false: True
str2 != null: True

Understanding the Evaluation

In the expression str == null == false, the evaluation proceeds as follows −

1. First, str == null is evaluated, returning true or false

2. Then, the result is compared with false

3. If str is null, we get true == false, which is false

4. If str is not null, we get false == false, which is true

Best Practices

While operator chaining is possible, it can make code less readable. For complex conditions, consider using parentheses for clarity or breaking the expression into separate statements −

using System;

class Program {
   public static void Main() {
      string text = "Sample";
      
      // Less clear
      bool result1 = text != null == true;
      
      // More clear
      bool result2 = (text != null) == true;
      
      // Even clearer
      bool isNotNull = text != null;
      bool result3 = isNotNull == true;
      
      Console.WriteLine("Less clear: " + result1);
      Console.WriteLine("More clear: " + result2);
      Console.WriteLine("Even clearer: " + result3);
   }
}

The output of the above code is −

Less clear: True
More clear: True
Even clearer: True

Conclusion

Chaining comparison operators in C# follows left-to-right associativity for operators of the same precedence. While this feature works correctly, using parentheses or breaking complex expressions into simpler parts improves code readability and reduces the chance of logical errors.