Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

Object.Equals (Método) (Object)

Determina si el objeto Object especificado es igual al objeto Object actual.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public virtual bool Equals(
	Object obj
)

Parámetros

obj
Tipo: System.Object
Objeto que se va a comparar con el objeto actual.

Valor devuelto

Tipo: System.Boolean
Es true si el objeto Object especificado es igual al objeto Object actual; en caso contrario, es false.

La implementación predeterminada de Equals admite la igualdad de referencias para los tipos de referencia, y la igualdad bit a bit para los tipos de valor. La igualdad de referencias significa que las referencias de objeto que se comparan hacen referencia al mismo objeto. La igualdad bit a bit significa los objetos que se comparan tienen la misma representación binaria.

Observe que un tipo derivado podría reemplazar el método Equals para implementar la igualdad de valores. La igualdad de valores significa que los objetos comparados tienen el mismo valor aunque tengan representaciones binarias diferentes. Por ejemplo, considere dos objetos Decimal que representan los números 1,10 y 1,1000. Los objetos Decimal no tienen igualdad bit a bit porque tienen representaciones binarias diferentes para tener en cuenta el diferente número de ceros finales. Sin embargo, los objetos tienen igualdad de valores porque los números 1,10 y 1,1000 se consideran iguales a efectos de comparación, ya que los ceros finales no son significativos.

Notas para los implementadores

Este método puede ser reemplazado por una clase derivada. Por ejemplo, muchos de los tipos de datos base devuelven true si ambos objetos representan el mismo valor; en caso contrario, devuelven false.

Este método sólo compara tipos primitivos y objetos. Se debe reemplazar para comparar estructuras más complejas, como matrices de objetos.

Las instrucciones siguientes deben ser true para todas las implementaciones del método Equals. En la lista, x, y, y z representan referencias a objetos que no son null.

  • x.Equals(x) devuelve true, salvo en los casos en que hay tipos de punto flotante. Consulte la norma IEC 60559:1989, Binary Floating-point Arithmetic for Microprocessor Systems (aritmética de punto flotante de tipo binario para sistemas de microprocesadores).

  • x.Equals(y) devuelve el mismo valor que y.Equals(x).

  • x.Equals(y) devuelve true si tanto x como y son NaN.

  • Si (x.Equals(y) && y.Equals(z)) devuelve true, entonces x.Equals(z) devuelve true.

  • Las llamadas sucesivas a x.Equals(y) devuelven el mismo valor siempre y cuando no se modifiquen los objetos a los que hacen referencia x e y.

  • x.Equals(null) devuelve false.

Vea GetHashCode para obtener información sobre otros comportamientos requeridos pertenecientes al método Equals.

Las implementaciones de Equals no deben producir excepciones.

Puede comparar el objeto actual con otro objeto para la igualdad de la referencia llamando al método ReferenceEquals. En Visual Basic, puede utilizar la palabra clave (por ejemplo, If Me Is otherObject Then …) is también.

En el caso de algunos tipos de objetos, es conveniente realizar una comprobación de Equals para comprobar así la igualdad de valores en lugar de la igualdad referencial. Este tipo de implementaciones de Equals devuelve true si los dos objetos tienen el mismo "valor", aunque no sean la misma instancia. El implementador de tipos decide qué es lo que constituye el "valor" de un objeto, pero suele ser una parte o la totalidad de los datos almacenados en las variables de instancia del objeto. Por ejemplo, el valor de String se basa en los caracteres de la cadena; el método Equals de la clase String devuelve true en el caso de que dos instancias de cadena contengan exactamente los mismos caracteres y en el mismo orden.

Los tipos que implementan IComparable deben reemplazar el método Equals.

Los tipos que reemplazan Equals también deben reemplazar GetHashCode; de lo contrario, puede que Hashtable no funcione correctamente.

Si el lenguaje de programación admite la sobrecarga de operadores y si se decide sobrecargar el operador de igualdad correspondiente a un tipo determinado, dicho tipo debe reemplazar el método Equals. Estas implementaciones del método Equals deben devolver los mismos resultados que el operador de igualdad. El cumplimiento de esta instrucción garantiza que el código de la biblioteca de clases que utiliza Equals (como ArrayList y Hashtable) se comporte de manera coherente con respecto a la forma en que el código de la aplicación utiliza el operador de igualdad.

Las instrucciones siguientes sirven para implementar un tipo de valor:

  • Considere la posibilidad de reemplazar Equals para obtener un rendimiento mayor que el que proporciona la implementación predeterminada de Equals en ValueType.

  • Si reemplaza el método Equals y el lenguaje admite la sobrecarga de operadores, debe sobrecargar el operador de igualdad correspondiente al tipo de valor.

Las instrucciones siguientes sirven para implementar un tipo de referencia:

  • Considere la posibilidad de reemplazar Equals en un tipo de referencia si la semántica del tipo se basa en el hecho de que este tipo representa algún valor o algunos valores.

  • La mayoría de los tipos de referencia no deben sobrecargar el operador de igualdad, aunque reemplacen el método Equals. No obstante, cuando se implemente un tipo de referencia destinado a tener semántica de valor, como un tipo de número complejo, debe reemplazarse el operador de igualdad.

En el siguiente ejemplo de código se compara la instancia actual con otro objeto.


using System;
class Program
{
    static void Main(string[] args)
    {
        Object Obj1 = new Object();
        Object Obj2 = new Object();
        Console.WriteLine(Obj1.Equals(Obj2));
        Obj2 = Obj1;
        Console.WriteLine(Obj1.Equals(Obj2)); 
    }
}

/* This example produces the following output:
False
True
 */


El siguiente ejemplo muestra una clase Point que reemplaza el método Equals para proporcionar igualdad de valores y una clase Point3D, que se deriva de Point. Dado que el reemplazo de Equals por parte de Point es el primero en la cadena de herencia para introducir la igualdad de valores, no se invoca el método Equals de la clase base (que se hereda de Object y comprueba la igualdad referencial). No obstante, Point3D.Equals invoca a Point.Equals porque Point implementa Equals de forma que se proporciona igualdad de valores.


using System;

class Point: Object {
   protected int x, y;

   public Point() {
     this.x = 0;
     this.y = 0;
   }

   public Point(int X, int Y) {
      this.x = X;
      this.y = Y;
   }

   public override bool Equals(Object obj) {
      //Check for null and compare run-time types.
      if (obj == null || GetType() != obj.GetType()) return false;
      Point p = (Point)obj;
      return (x == p.x) && (y == p.y);
   }

   public override int GetHashCode() {
      return x ^ y;
   }
}


class Point3D: Point {
   int z;

   public Point3D(int X, int Y, int Z) {
      this.x = X;
      this.y = Y;
      this.z = Z; 
   }

   public override bool Equals(Object obj) {
      return base.Equals(obj) && z == ((Point3D)obj).z;
   }

   public override int GetHashCode() {
      return base.GetHashCode() ^ z;
   }
}

class MyClass {

  public static void Main() {
     Point point2D = new Point(5, 5);
     Point3D point3Da = new Point3D(5, 5, 2);
     Point3D point3Db = new Point3D(5, 5, 2);

     if (!point2D.Equals(point3Da)) {
        Console.WriteLine("point2D does not equal point3Da.");
     }
     if (!point3Db.Equals(point2D)) {
        Console.WriteLine("Likewise, point3Db does not equal point2D.");
     }
     if (point3Da.Equals(point3Db)) {
        Console.WriteLine("However, point3Da equals point3Db.");
     }

  } 
}
// ----------------------------------
// Output should be:
// 
// point2D does not equal point3Da.
// Likewise, point3Db does not equal point2D.
// However, point3Da equals point3Db.


El método Point.Equals comprueba que el argumento obj no es null y que hace referencia a una instancia del mismo tipo que este objeto. Si alguna de las comprobaciones no es satisfactoria, el método devuelve false.

El método Equals utiliza GetType para determinar si los tipos en tiempo de ejecución de los dos objetos son idénticos. Conviene señalar que typeof no se utiliza aquí porque devuelve el tipo estático. Si el método utilizó una comprobación de la forma obj is Point, la comprobación devolverá true en los casos en los que obj sea una instancia de una clase derivada de Point, aunque obj y la instancia actual no tengan el mismo tipo en tiempo de ejecución. Una vez que se haya comprobado que ambos objetos son del mismo tipo, el método convierte obj en el tipo Point y devuelve el resultado de comparar las variables de instancia de los dos objetos.

En Point3D.Equals, el método Equals heredado se invoca antes que nada; el método Equals heredado comprueba si obj no es null, si obj es una instancia de la misma clase que este objeto y si las variables de instancia heredadas coinciden. Sólo cuando el Equals heredado devuelva true el método comparará las variables de instancia introducidas en la clase derivada. Concretamente, la conversión en Point3D no se ejecuta salvo que se haya determinado que obj sea de tipo Point3D o una clase derivada de Point3D.

En el ejemplo anterior, operator == (operador de igualdad) se utiliza para comparar las variables de instancia individuales. En algunos casos, debe utilizarse el método Equals para comparar variables de instancia en una implementación de Equals, tal y como se muestra en el siguiente ejemplo de código.


using System;

class Rectangle {
   Point a, b;

   public Rectangle(int upLeftX, int upLeftY, int downRightX, int downRightY) {
      this.a = new Point(upLeftX, upLeftY);
      this.b = new Point(downRightX, downRightY);
   }

   public override bool Equals(Object obj) {
     // Performs an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType()) return false;
      Rectangle r = (Rectangle)obj;
      //Uses Equals to compare variables.
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode() {
      return a.GetHashCode() ^ b.GetHashCode();
   }
}

// Class Point added for clean compile
class Point {
  private int x;
  private int y;

  public Point(int X, int Y) {
     this.x = X;
     this.y = Y;
  }

  public override bool Equals (Object obj) {
     // Performs an equality check on two points (integer pairs).
     if (obj == null || GetType() != obj.GetType()) return false;
     Point p = (Point)obj;
     return (x == p.x) && (y == p.y);
  }

  public override int GetHashCode() {
     return x.GetHashCode() ^ y.GetHashCode();
  }

}

class MyClass {
   public static void Main() {

      Rectangle r1 = new Rectangle(0, 0, 100, 200);
      Rectangle r2 = new Rectangle(0, 0, 100, 200);
      Rectangle r3 = new Rectangle(0, 0, 150, 200);

      if (r1.Equals(r2)) {
         Console.WriteLine("Rectangle r1 equals rectangle r2!");
      }
      if (!r2.Equals(r3)) {
         Console.WriteLine("But rectangle r2 does not equal rectangle r3.");
      }
   }
}
// ------------------------------
// Output should be:
// Rectangle r1 equals rectangle r2!
// But rectangle r2 does not equal rectangle r3.


En algunos lenguajes, como C# y Visual Basic, la sobrecarga de operadores se admite. Cuando un tipo sobrecarga el operador de igualdad, también debe reemplazar el método Equals para ofrecer la misma funcionalidad. Esto se consigue normalmente escribiendo el método Equals en términos del operador de igualdad sobrecargado, como en el siguiente ejemplo de código.


using System;

public struct Complex {
   public double re, im;

   public override bool Equals(Object obj) {
      return obj is Complex && this == (Complex)obj;
   }

   public override int GetHashCode() {
      return re.GetHashCode() ^ im.GetHashCode();
   }

   public static bool operator ==(Complex x, Complex y) {
      return x.re == y.re && x.im == y.im;
   }

   public static bool operator !=(Complex x, Complex y) {
      return !(x == y);
   }
}

class MyClass {

  public static void Main() {
    Complex cmplx1, cmplx2;

    cmplx1.re = 4.0;
    cmplx1.im = 1.0;

    cmplx2.re = 2.0;
    cmplx2.im = 1.0;

    if (cmplx1 != cmplx2)
      Console.WriteLine("The two objects are not equal.");
    if (! cmplx1.Equals(cmplx2))
      Console.WriteLine("The two objects are not equal.");

    cmplx2.re = 4.0;

    if (cmplx1 == cmplx2) 
      Console.WriteLine("The two objects are now equal!");
    if (cmplx1.Equals(cmplx2)) 
      Console.WriteLine("The two objects are now equal!");
  }
}
// The example displays the following output:
//       The two objects are not equal.
//       The two objects are not equal.
//       The two objects are now equal!
//       The two objects are now equal!


Dado que Complex es un struct de C# (un tipo de valor), no admite la acción de derivar; por lo tanto, el método Equals no necesita comparar los resultados de GetType para cada objeto; en su lugar se puede utilizar el operador is para comprobar el tipo del parámetro obj.

.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

date

Historial

Motivo

Octubre de 2010

Revisado el último ejemplo.

Comentarios de los clientes.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft