a.Equals(b) , a == b及Object.ReferenceEquals( a , b )的区别

For value types, “==” and Equals() works same way : Compare two objects by VALUE
Example:
int i = 5;
int k= 5;
i == k => True
i.Equals(k) => True

Reference Types:
For reference types, both works differently :
“==” compares reference – you can say identity of objects and returns true if and only if both
references point to the SAME object while
Equals method compares object by VALUE and it will return true if the references refers object
which are equivalent
Example: StringBuilder sb1 = new StringBuilder(“Mahesh”);
StringBuilder sb2 = new StringBuilder(“Mahesh”);
sb1 == sb2 => False
sb1.Equals(sb2) => True

But now look at following issue:
String s1 = “Mahesh”;
String s2 = “Mahesh”;
In above case the results will be,
s1 == s2 => True
s1.Equals(s2 ) => True
String is actually reference type : it’s a sequence of “Char” and it’s also immutable but as you saw
above, it will behave like Value Types in this case.
Exceptions are always there ;)

Now another interesting case:
int i = 0;
byte b = 0;
i == b > True
i.Equals(b) > False
So, it means Equals method compare not only value but it compares TYPE also in Value Types.

Recommendation:
For value types: use “==”
For reference types: use Equals method.
Some interesting facts:
Why to prefer Equals method in especially VB.Net?
Consider following snippet:
Public Sub doSomething()
Dim s1 As String = “Mahesh”
Dim s2 As String = “Mahesh”
If s1 = s2 Then
MessageBox.Show(“Same!”)
End If
If s1.Equals(s2) Then
MessageBox.Show(“Not same!”)
End If
End Sub

Now if you will compile this stuff, and check generated IL code [Use ILDASM.exe ships with .Net
Framework], you will find,
in doSomething section, “=” will create,
IL_0010: call int32
[Microsoft.VisualBasic]Microsoft.VisualBasic.CompilerServices.StringType::StrCmp(string,string,bool)

And, Equals method will create,
IL_0026: callvirt instance bool [mscorlib]System.String::Equals(string)
The second approach, using Equals uses mscorlib and its smaller and faster than the “=”
because “=” uses VB.NET specific string comparison logic instead of core .Net implementation.
Single comparison operation may not give you performance hit but looping or at some critical part
of you code, it can.
So Equals just give some efficient code.
More interesting thing that in C#, for the above code snippet, “==” and “Equals” both will result in
same IL code. so no ambiguity in C#.
But if you used to code in both the language, then its obviously preferable to use Equals method.