The difference between == and equals() in C#

Such as the following code:

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

int and short are primitive types, but comparison with "==" returns true, and equals() returns false. why?

Answers:

In short:

"equals()" is more complicated than "==".

Specifically:
The original type overrides (override) object.Equals(object) of the base class, and returns true when the object in the brackets is the same as its type and value (note that the Nullable type is also suitable for the above judgment; the non-empty Nullable type Always boxed to a base type instance).

Since newAge is short, newAge.Equals(object) returns true when object is short and the value is equal to the newAge value. What you are passing is an int object, so it returns false.

In contrast, the "==" operator is defined as an operation with two integers (int) or two short integers (short) or two long integers (long). When the two parameters of "==" are an integer and a short integer, the compiler will implicitly convert short to int and compare the size of the converted int value.

Other ways to make it work:

Primitive types also have their own equals() method, equals accepts parameters of the same type.

If you write age.Equals(newAge), the compiler will choose int.Equals(int) as the best overload method and implicitly convert short to int. Then, it will return true because this method directly compares the size of two int values.

short also has a short.Equals(short) method, but the int type cannot be implicitly converted to short, so it will not be called.

You can force this method to be called using a cast conversion:

Console.Writeline（newAge.Equals（（short）age））; //true

This will call short.Equals(short) directly, no boxing operation. If age is greater than 32767, it will throw an overflow exception.

You can also call the short.Equals(object) overload, but you need to explicitly pass a boxed object of the same type:

Console.WriteLine(newAge.Equals((object)(short)age)); // true

Like the previous optional method (short.Equals(short)), If the size exceeds the short range, an overflow exception is also thrown. Unlike previous solutions, it boxes short into an object - a waste of time and memory.

Source Code:

Here is the Equals() actually used:

 public override bool Equals(Object obj) {
 
        if (!(obj is Int16)) {
 
            return false;
 
        }
 
        return m_value == ((Int16)obj).m_value;
 
    }
 
    public bool Equals(Int16 obj)
 
    {
 
        return m_value == obj;
 
    }

For more articles related to the difference between == and equals() in C#, please pay attention to the PHP Chinese website!