== vs Equals in C#: Key Differences and When to Use Each

In C#, the == operator compares values or references depending on the type, while the Equals method checks for value equality and can be overridden for custom types. Use == for simple comparisons and Equals when you want to ensure logical equality, especially with objects.

Quick Comparison

This table summarizes the main differences between == and Equals in C#.

Aspect	== Operator	Equals Method
Type of comparison	Value or reference depending on type	Value equality, can be overridden
Default behavior for reference types	Reference equality (same object)	Reference equality unless overridden
Default behavior for value types	Value equality	Value equality
Can be overridden?	Yes, by overloading operator	Yes, by overriding method
Null safety	== handles nulls safely	Equals throws if called on null
Usage	Simple, often for primitives and strings	For custom equality logic

Key Differences

The == operator in C# is a binary operator that compares two operands. For value types like int or double, it compares the actual values. For reference types like classes, by default it compares whether both operands refer to the same object in memory (reference equality). However, some types like string override == to compare values instead.

The Equals method is a virtual method defined in System.Object. It is intended to check logical equality of objects. By default, it behaves like reference equality for reference types, but many classes override it to compare internal data (value equality). For value types, Equals compares the values.

Another difference is that == can be overloaded by a class to provide custom comparison logic, while Equals can be overridden. Also, == handles null comparisons safely, but calling Equals on a null object will throw a NullReferenceException.

Code Comparison

csharp

using System;

class Program
{
    static void Main()
    {
        string a = "hello";
        string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

        Console.WriteLine(a == b);       // True because string overrides ==
        Console.WriteLine(a.Equals(b));  // True because string overrides Equals

        object obj1 = a;
        object obj2 = b;

        Console.WriteLine(obj1 == obj2);       // False, compares references
        Console.WriteLine(obj1.Equals(obj2));  // True, string Equals compares values
    }
}

Output

True
True
False
True

Equals Method Equivalent

csharp

using System;

class Program
{
    static void Main()
    {
        int x = 5;
        int y = 5;

        Console.WriteLine(x == y);          // True, value comparison
        Console.WriteLine(x.Equals(y));     // True, value comparison

        object obj1 = x;
        object obj2 = y;

        Console.WriteLine(obj1 == obj2);    // False, reference comparison
        Console.WriteLine(obj1.Equals(obj2)); // True, value comparison
    }
}

Output

True
True
False
True

When to Use Which

Choose == when you want a quick, simple comparison, especially for primitive types and strings where it is already overridden to check values. It is also safer for null checks because it won't throw exceptions.

Choose Equals when you want to check logical equality for objects, especially custom classes that override Equals to compare internal data. Use it when you want consistent behavior regardless of reference or value type.

In general, for custom types, override Equals and use it for equality checks, and consider overloading == for syntactic convenience.

Key Takeaways

== compares values or references depending on type and can be overloaded.

Equals checks logical equality and is often overridden in custom classes.

== is null-safe; calling Equals on null throws an exception.

Use == for simple, built-in type comparisons and Equals for custom equality logic.

For custom classes, override Equals and consider overloading == for clarity.