What is the difference between .Equals and == [duplicate]

Question

What is the difference between a.Equals(b) and a == b for value types, reference types, and strings? It would seem as though a == b works just fine for strings, but I'm trying to be sure to use good coding practices.

Answer 1

From When should I use Equals and when should I use ==:

The Equals method is just a virtual one defined in System.Object, and overridden by whichever classes choose to do so. The == operator is an operator which can be overloaded by classes, but which usually has identity behaviour.

For reference types where == has not been overloaded, it compares whether two references refer to the same object - which is exactly what the implementation of Equals does in System.Object.

Value types do not provide an overload for == by default. However, most of the value types provided by the framework provide their own overload. The default implementation of Equals for a value type is provided by ValueType, and uses reflection to make the comparison, which makes it significantly slower than a type-specific implementation normally would be. This implementation also calls Equals on pairs of references within the two values being compared.

using System;  public class Test {     static void Main()     {         // Create two equal but distinct strings         string a = new string(new char[] {'h', 'e', 'l', 'l', 'o'});         string b = new string(new char[] {'h', 'e', 'l', 'l', 'o'});          Console.WriteLine (a==b);         Console.WriteLine (a.Equals(b));          // Now let's see what happens with the same tests but         // with variables of type object         object c = a;         object d = b;          Console.WriteLine (c==d);         Console.WriteLine (c.Equals(d));     } } 

The result of this short sample program is

True True False True 

Answer 2

Here is a great blog post about WHY the implementations are different.

Essentially == is going to be bound at compile time using the types of the variables and .Equals is going to be dynamically bound at runtime.