C# - Comparison Operators

Comparison Operators in C# 

Introduction to C# Comparison Operators

C# Comparison Operators are fundamental building blocks in C# programming that allow developers to compare two values, variables, or expressions. These operators return a Boolean result — either true or false — which is essential for decision-making, control flow, conditional statements, loops, and logical operations.

In C# programming, comparison operators are widely used in if statements, switch expressions, while loops, for loops, LINQ queries, object comparisons, and advanced .NET applications. Understanding how C# comparison operators work is crucial for writing efficient, readable, and maintainable code.

This comprehensive guide will explore all C# comparison operators in detail, including equality operators, relational operators, operator overloading, string comparisons, object comparisons, nullable comparisons, and performance considerations. By the end of this tutorial, you will have a strong understanding of how to use comparison operators effectively in real-world C# development.

What Are Comparison Operators in C#?

Comparison operators in C# are used to compare two operands and determine the relationship between them. The result of any comparison operator is always a Boolean value (true or false).

These operators are commonly used in:

• If-else statements
• Loops (for, while, do-while)
• Ternary conditional operator
• LINQ queries
• Validation logic
• Sorting and filtering operations

List of C# Comparison Operators

Below is a complete list of relational and equality operators in C#:

• == (Equal to)
• != (Not equal to)
• > (Greater than)
• < (Less than)
• >= (Greater than or equal to)
• <= (Less than or equal to)

1. Equality Operator (==) in C#

The equality operator (==) checks whether two operands are equal. If both values are equal, it returns true; otherwise, it returns false.

Example: Equality Operator

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = 10;

        bool result = (a == b);
        Console.WriteLine(result);
    }
}

Output:

True

This operator works with numeric types, characters, Boolean values, and even objects (with certain conditions).

2. Inequality Operator (!=) in C#

The != operator checks whether two operands are not equal.

Example: Inequality Operator

int x = 5;
int y = 10;

bool result = (x != y);
Console.WriteLine(result);

If the values differ, the result will be true.

3. Greater Than Operator (>)

The greater than operator checks whether the left operand is greater than the right operand.

Example

int age = 25;

bool isAdult = age > 18;
Console.WriteLine(isAdult);

4. Less Than Operator (<)

The less than operator checks whether the left operand is less than the right operand.

Example

int temperature = 15;

bool isCold = temperature < 20;
Console.WriteLine(isCold);

5. Greater Than or Equal To (>=)

This operator checks if the left operand is greater than or equal to the right operand.

Example

int marks = 40;

bool passed = marks >= 40;
Console.WriteLine(passed);

6. Less Than or Equal To (<=)

This operator checks if the left operand is less than or equal to the right operand.

Example

int speed = 60;

bool withinLimit = speed <= 80;
Console.WriteLine(withinLimit);

Comparison Operators with Different Data Types

1. Numeric Comparisons

Comparison operators work seamlessly with int, double, float, decimal, and long types.

2. String Comparisons in C#

String comparison using == checks for value equality, not reference equality in C#. Internally, it compares the string contents.

string s1 = "hello";
string s2 = "hello";

Console.WriteLine(s1 == s2);

For case-insensitive comparisons, use String.Equals method.

string name1 = "John";
string name2 = "john";

bool result = name1.Equals(name2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine(result);

Reference Type Comparison in C#

When comparing objects, == may behave differently depending on operator overloading. By default, reference types compare memory references.

class Person
{
    public string Name;
}

Person p1 = new Person();
Person p2 = new Person();

Console.WriteLine(p1 == p2);

This will return false because they reference different objects in memory.

Operator Overloading in C#

C# allows custom classes to overload comparison operators.

Example of Overloading == Operator

class Rectangle
{
    public int Width;
    public int Height;

    public static bool operator ==(Rectangle r1, Rectangle r2)
    {
        return r1.Width == r2.Width && r1.Height == r2.Height;
    }

    public static bool operator !=(Rectangle r1, Rectangle r2)
    {
        return !(r1 == r2);
    }
}

Operator overloading enhances flexibility but must be implemented carefully to maintain consistency.

Comparison Operators in Conditional Statements

Comparison operators are frequently used inside conditional statements.

int score = 75;

if (score >= 50)
{
    Console.WriteLine("Pass");
}
else
{
    Console.WriteLine("Fail");
}

Using Comparison Operators in Loops

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

The loop continues while the condition i < 5 evaluates to true.

Comparison with Nullable Types

Nullable types (int?, double?, etc.) can also be compared.

int? a = null;
int? b = 10;

Console.WriteLine(a == b);
Console.WriteLine(a != null);

C# handles null comparisons safely using built-in rules.

Common Mistakes with Comparison Operators

• Using = instead of ==
• Ignoring case sensitivity in strings
• Not handling null references
• Incorrect operator overloading
• Comparing floating point numbers without tolerance

Performance Considerations

Comparison operators are highly optimized in the .NET runtime. However:

• String comparisons can be expensive.
• Boxing may affect performance.
• Custom operator overloads must be efficient.

Advanced Topics in C# Comparison

Pattern Matching with Comparison

int number = 15;

if (number is > 10 and < 20)
{
    Console.WriteLine("Between 10 and 20");
}

CompareTo Method

int result = 5.CompareTo(10);
Console.WriteLine(result);

The CompareTo method returns:

• Less than 0 if smaller
• 0 if equal
• Greater than 0 if larger

C# Comparison Operators are essential tools in C# programming. From simple numeric comparisons to complex object equality checks and operator overloading, these operators power decision-making and control flow in modern .NET applications.

Mastering C# equality operators, relational operators, Boolean expressions, and comparison techniques ensures that your code remains efficient, readable, and reliable. Whether you are a beginner learning C# fundamentals or an advanced developer building enterprise-level applications, understanding comparison operators deeply will significantly improve your programming skills.