Comparison and Equality

Comparison operators ask a question about two values and answer true or false. There are six: < less than, > greater than, <= less than or equal, >= greater than or equal, == equal, and != not equal. Equality is two equals signs. One equals sign assigns a value instead, which is a different thing entirely.

Two meanings of equal

What == compares depends on the kind of type. For a value type such as int, double, char or bool, the contents are compared: two variables holding 5 are equal. For most reference types, == compares identity. Two objects are equal only when both variables point at the same object, even when their contents match exactly.

string is the exception

string is a reference type, but it defines its own == that compares the characters. Two separate string objects holding "hello" are equal. That comparison is case-sensitive, so "ADMIN" == "admin" is false. Use string.Equals(a, b, StringComparison.OrdinalIgnoreCase) when case should not matter.

What trips people up

A string's special == is chosen by the compiler from the declared types, so it disappears when the compiler cannot see strings. Put the same two strings in variables declared as object and == silently goes back to comparing identity. The Equals method is chosen by the object itself at run time, so it keeps comparing the text.

using System.Text;

int left = 5;
int right = 5;

// int is a value type, so == compares the numbers themselves.
Console.WriteLine(left == right);
Console.WriteLine(left >= right);
Console.WriteLine(left != right);

string first = "hello";
string second = "hel";
second = second + "lo";   // joined while the program runs, so a second object

// string defines its own ==, which compares the characters.
Console.WriteLine(first == second);
// They really are two different objects in memory, though.
Console.WriteLine(object.ReferenceEquals(first, second));

// StringBuilder does not define ==, so == asks "the same object?"
var one = new StringBuilder("hello");
var two = new StringBuilder("hello");
Console.WriteLine(one == two);
Console.WriteLine(one.ToString() == two.ToString());

// Output:
// True
// True
// False
// True
// False
// False
// True

string first = "hello";
string second = "hel";
second = second + "lo";

// The compiler sees two strings, so it uses string's ==: characters compared.
Console.WriteLine(first == second);

object boxedFirst = first;
object boxedSecond = second;

// Both variables are declared object, so the compiler uses object's ==,
// which compares references. The characters are never looked at.
Console.WriteLine(boxedFirst == boxedSecond);

// Equals is picked by the real object at run time, so the text wins again.
Console.WriteLine(boxedFirst.Equals(boxedSecond));

// Output:
// True
// False
// True

string typed = "ADMIN";
string expected = "admin";

// == on strings is case-sensitive.
Console.WriteLine(typed == expected);

// string.Equals takes a third argument saying how to compare.
Console.WriteLine(string.Equals(typed, expected, StringComparison.OrdinalIgnoreCase));

// Output:
// False
// True

double computed = 0.1 + 0.2;
double expected = 0.3;

// Binary fractions are approximate, so the exact test fails.
Console.WriteLine(computed == expected);

// Compare the size of the difference against a tolerance instead.
Console.WriteLine(Math.Abs(computed - expected) < 0.000001);

// Output:
// False
// True