Question: Consider this code:

```
int age = 25;
short newAge = 25;
Console.WriteLine(age == newAge);  //true
Console.WriteLine(newAge.Equals(age)); //false
Console.ReadLine();

```

Both `int` and `short` are primitive types, but a comparison with `==` returns true and a comparison with `Equals` returns false.

Why?

Answer: 
`==` is used for checking a equal condition, it can be considered as an operator(boolean operator), just to compare 2 things and here the data type doesn't matter as there would be a type casting done and `Equals` is also used for checking equals condition, but in this case the data types should be same. N Equals is a method not an operator.

Below is a small example taken from the one you provided and this will clarify difference in brief,.

```
int x=1;
short y=1;
x==y;//true
y.Equals(x);//false

```

in the above example, X and Y have same values i.e. 1, and when we use `==`, it will return true, as in case of `==`, the short type is converted to int by the compiler and the result is given.

and when we use `Equals`, the comparing is done, but the type casting is not done by compiler, so false is returned.

Guys, please let me know if I'm wrong.
What you need to realize is that doing `==` will always end up calling a method. The question is whether calling `==` and `Equals` ends up calling/doing the same things.

With reference types, `==` will always 1st check whether the references are the same (`Object.ReferenceEquals`). `Equals` on the other hand can be overridden and may check whether some values are equal.

EDIT: to answer svick and add on SLaks comment, here is some IL code

```
int i1 = 0x22; // ldc.i4.s ie pushes an int32 on the stack
int i2 = 0x33; // ldc.i4.s 
short s1 = 0x11; // ldc.i4.s (same as for int32)
short s2 = 0x22; // ldc.i4.s 

s1 == i1 // ceq
i1 == s1 // ceq
i1 == i2 // ceq
s1 == s2 // ceq
// no difference between int and short for those 4 cases,
// anyway the shorts are pushed as integers.

i1.Equals(i2) // calls System.Int32.Equals
s1.Equals(s2) // calls System.Int16.Equals
i1.Equals(s1) // calls System.Int32.Equals: s1 is considered as an integer
// - again it was pushed as such on the stack)
s1.Equals(i1) // boxes the int32 then calls System.Int16.Equals
// - int16 has 2 Equals methods: one for in16 and one for Object.
// Casting an int32 into an int16 is not safe, so the Object overload
// must be used instead.

```