When should I use == and when should I use Equals?

When should I use == and when should I use Equals?

Rate This
  • Comments 28

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.

However, the main difference between the two types of comparison in normal use (where you're unlikely to be defining your own value types very often) is polymorphism. Operators are overloaded, not overridden, which means that unless the compiler knows to call the more specific version, it'll just call the identity version. To illustrate that, here's an example:

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 results are:


The third line is False because the compiler can only call the non-overloaded version of == as it doesn't know that the contents of c and d are both string references. As they are references to different strings, the identity operator returns false.

So, when should you use which operator? My rule of thumb is that for almost all reference types, use Equals when you want to test equality rather than reference identity. The exception is for strings - comparing strings with == does make things an awful lot simpler and more readable but you need to remember that both sides of the operator must be expressions of type string in order to get the comparison to work properly.

For value types, I'd normally use == for easier-to-read code. Things would get tricky if a value type provided an overload for == which acted differently to Equals, but I'd consider such a type very badly designed to start with.

[Author: Jon Skeet]

Leave a Comment
  • Please add 8 and 3 and type the answer here:
  • Post
  • The notion of identity and equivalence is fundamental, yet very confusing at times. You might end up
  • .NETFramework类库提供了静态方法publicstaticboolReferenceEquals(

  • PingBack from http://protsyk.com/cms/?p=140

  • PingBack from http://cellulitecreamsite.info/story.php?id=8552

  • This post doesn't mention the fact that the compiler doesn't do type checking with .Equals but it does with ==.


    string mystring = "hello";

    int num = 1;

    bool result = mystring.Equals(num); // this compiles OK!

    bool result2 = mystring == num;     // this won't compile - good

  • Very Clear Explanation. Thanks.!

  • // Create two equal but distinct strings

               string a = "1"; //new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

               string b = "1"; //new string(new char[] { 'h', 'e', 'l', 'l', 'o' });

               Console.WriteLine(a == 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);



    Why all 4 statements are true in this code ? Please explain ...

  • check this link ....a nice explanation of this



  • Thanks for this brief yet concise difference.

  • For those who are interested, here's a blog which benchmarks the fastest way to compare strings in C#:



  • now i'm clear about == operator AND Equals method


  • Maybe mention nullables? They are structs, so I assume it's better to use == than Equals().

  • Because if two string literals contains same value then it will pooled in same memory location.

    Hence the below code

    string a="1";

    object b="1";





    Because both are pointing to same memory location.

    if you try this below code

    string a="1";

    object b="2";





    Because both variables point to their own memory location with different values and these values are not pooled.

Page 2 of 2 (28 items) 12