What is the difference between a.Equals(b) and 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

For reference types : both works differently :
“==” compares reference – 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 : its a sequence of “Char” and its 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(s1) 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.

/////////////////////////////////////////////////////////////////////////////////////

Both are used for comparison of variables, can be overloaded and return a Boolean value.

The differences are:-

Consider two variables of different types:
1) int a = 20;
string b = "20";

//Compiler error (== cannot be applied to int and string)
Console.WriteLine(a == b);

//output: False
Console.WriteLine(a.Equals(b));

2)int c = 455;
long f = 455;
//True
Console.WriteLine(c == f);
//False
Console.WriteLine(c.Equals(f));

//Equals strictly checks that 2 variables should be of the same type

// == gives True if 2 variables ' data types allow for similar values(Example: int and long)

3)List y = new List();
y.Add("one");
List z = new List();
z.Add("one");
Console.WriteLine(y == z);
Console.WriteLine(y.Equals(z));

Both will give False.