The predefined reference type equality operators are:
bool operator ==(object x, object y);
bool operator !=(object x, object y);
The operators return the result of comparing the two references for equality
or non-equality.
Since the predefined reference type equality operators accept operands of
type object, they apply to all
types that do not declare applicable operator == and operator != members.
Conversely, any
applicable user-defined equality operators effectively hide the predefined
reference type equality operators.
The predefined reference type equality operators require the operands to be
reference-type values or the
value null; furthermore, they require that a standard implicit conversion (?
3.3.1) exists from the type of
either operand to the type of the other operand. Unless both of these
conditions are true, a compile-time error
occurs. [Note: Notable implications of these rules are:
?It is a compile-time error to use the predefined reference type equality
operators to compare two
references that are known to be different at compile-time. [Example: For
example, if the compile-time
types of the operands are two class types A and B, and if neither A nor B
derives from the other, then it
would be impossible for the two operands to reference the same object.
Thus, the operation is considered
a compile-time error. end example]
?The predefined reference type equality operators do not permit value type
operands to be compared.
Therefore, unless a struct type declares its own equality operators, it is
not possible to compare values of
that struct type.
?The predefined reference type equality operators never cause boxing
operations to occur for their
operands. It would be meaningless to perform such boxing operations, since
references to the newly
allocated boxed instances would necessarily differ from all other
references.
end note]
For an operation of the form x == y or x != y, if any applicable operator
== or operator != exists,
the operator overload resolution (?4.2.4) rules will select that operator
instead of the predefined reference
type equality operator. However, it is always possible to select the
predefined reference type equality
operator by explicitly casting one or both of the operands to type object.
[Example: The example
Chapter 14 Expressions
167
using System;
class Test
{
static void Main() {
string s = "Test";
string t = string.Copy(s);
Console.WriteLine(s == t);
Console.WriteLine((object)s == t);
Console.WriteLine(s == (object)t);
Console.WriteLine((object)s == (object)t);
}
}
produces the output
True
False
False
False
The s and t variables refer to two distinct string instances containing the
same characters. The first
comparison outputs True because the predefined string equality operator (?4.
9.7) is selected when both
operands are of type string. The remaining comparisons all output False
because the predefined
reference type equality operator is selected when one or both of the
operands are of type object.
Note that the above technique is not meaningful for value types. The example
class Test
{
static void Main() {
int i = 123;
int j = 123;
System.Console.WriteLine((object)i == (object)j);
}
}
outputs False because the casts create references to two separate instances
of boxed int values. end
example]
