Exportar (0) Imprimir
Expandir todo

7.9.6 Operadores de igualdad de tipos de referencia

Visual Studio .NET 2003

Los operadores de igualdad de tipos de referencia predefinidos son:

bool operator ==(object x, object y);
bool operator !=(object x, object y);

Los operadores devuelven el resultado de comparar la igualdad o desigualdad de las dos referencias.

Dado que los operadores de igualdad de tipos de referencia predefinidos aceptan operandos de tipo object, se aplican a todos los tipos que no declaran miembros aplicables operator == y operator !=. A la inversa, cualquier operador de igualdad aplicable definido por el usuario oculta los operadores de igualdad predefinidos de tipos de referencia.

Los operadores de igualdad de tipo de referencia predefinidos requieren que los operandos sean valores de tipo de referencia o el valor null; además, requieren que exista una conversión implícita estándar (Sección 6.3.1) del tipo de uno de los operandos al tipo del otro operando. A menos que estas dos condiciones sean verdaderas, se producirá un error de compilación. Son implicaciones notables de estas reglas:

  • Produce un error durante la compilación utilizar los operadores de igualdad de tipos de referencia predefinidos para comparar dos referencias de las que se sabe que son diferentes en tiempo de compilación. Por ejemplo, si los tipos de los operandos en tiempo de compilación fueran dos tipos de clases A y B, y si ni A ni B se derivaran del otro, no sería posible que los operandos hicieran referencia al mismo objeto. Por lo tanto, la operación se considera un error de compilación.
  • Los operadores de igualdad de tipos de referencia predefinidos no permiten la comparación de operandos de tipo de valor. Por lo tanto, salvo que un tipo struct declare sus propios operadores de igualdad, no es posible comparar valores de ese tipo struct.
  • Los operadores de igualdad de tipos de referencia predefinidos nunca causan operaciones boxing para sus operandos. No tendría sentido realizar este tipo de operaciones boxing, puesto que las referencias a las instancias convertidas mediante boxing recién asignadas diferirían necesariamente de todas las demás referencias.

Para una operación de la forma x == y o x != y, si existe un operator == o operator != aplicable, las reglas de resolución de sobrecargas de operador (Sección 7.2.4) seleccionan este operador en lugar del operador de igualdad de tipos de referencia predefinido. No obstante, siempre es posible seleccionar el operador de igualdad de tipos de referencia predefinido mediante la conversión explícita de uno o los dos operandos al tipo object. El ejemplo

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);
   }
}

produce el resultado

True
False
False
False

Las variables s y t hacen referencia a las dos instancias únicas de string que contienen los mismos caracteres. La primera comparación produce True a causa de la selección del operador de igualdad de cadenas predefinido (Sección 7.9.7) cuando los dos operandos son de tipo string. Todas las comparaciones restantes producen False a causa de la selección del operador de igualdad de tipos de referencia predefinido cuando uno o los dos operandos son de tipo object.

Téngase en cuenta que la técnica anterior no tiene sentido para los tipos de valor. El ejemplo

class Test
{
   static void Main() {
      int i = 123;
      int j = 123;
      System.Console.WriteLine((object)i == (object)j);
   }
}

produce False por las conversiones de tipos crean referencias a dos instancias distintas de valores int convertidos mediante boxing.

Mostrar:
© 2014 Microsoft