I searched the source code of FCL, and I got confused that string.Equals() uses Object.ReferenceEquals(), and Object.ReferenceEquals() uses == operator to jugde. And then I can't find how the == operator is defined.
So where is the original operator defined?
This is an operator that the language uses to validate that two values are the same. When your code would be compiled this operator would be compiled appropriately in CIL and then when we will be executed by the CLR the two values would be compared to be checked if they are the same.
For instance, this is the CIL code for the Main method:
that the compiler produces for the following program (it's a console application):
class Program
{
static void Main(string[] args)
{
int a = 3;
int b = 4;
bool areEqual = a == b;
Console.WriteLine(areEqual);
}
}
Note the IL_0007 line. There a ceq instruction has been emitted. This is that you are looking for, the == operator.
Important Note
This is happening when the == is not overloaded.
When there isn't an overloaded == operator (as here), the compiler emits a ceq instruction. There's no more C# code to look at at this point.
Compares two values. If they are equal, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise 0 (int32) is pushed onto the evaluation stack.
Overloading operator== in C# is syntactic sugar for calling a static function. The overload resolution, like all overload resolution, happens based on the static type of the object, not the dynamic type. Let's look at Object.ReferenceEquals again:
public static bool ReferenceEquals (Object objA, Object objB) {
return objA == objB;
}
Here, the static type of objA and objB is Object. The dynamic type can be anything; a string, some other user defined type, whatever; that does not matter. The determination of which operator== is called is determined statically when this function is compiled, so you always get the default, non-overloaded, built in language-supplied one. .NET could just have not had a ReferenceEquals and let users do ((object)a) == ((object)b), but having a specific named function to say what's going on improves clarity.
Object.Equals, on the other hand, is just a virtual function. As a result, which Equals is chosen is based on the dynamic type of the object to the left of the .Equals(, like any other virtual function call.
ceq takes two values from the stack and gives results. If the result value is 1 then they are considered equal and 0 if they are not equal.
However, the == operator doesn't always get translated to ceq.
Whether == in C# results in ceq depends on some more factors like are data types primitives or do they have custom == operators or are they references.
