Object.Equals (Método) (Object)

El tipo de comparación entre la instancia actual y el parámetro obj depende de si la instancia actual es un tipo de referencia o un tipo de valor. Si la instancia actual es un tipo de referencia, el método Equals(Object) prueba de igualdad de referencia, y una llamada al método Equals(Object) equivale a una llamada al método ReferenceEquals . La igualdad de referencias significa que las variables de objeto se comparan que hacen referencia al mismo objeto. El ejemplo siguiente se muestra el resultado de la comparación. Define una clase Person , que es un tipo de referencia, y llama al constructor de clase Person para crear instancias de dos objetos nuevos, person1a y person2de Person , que tienen el mismo valor. También asigna person1a a otra variable de objeto, person1b. Como muestra el resultado del ejemplo, person1a y person1b son iguales porque hacen referencia al mismo objeto. Sin embargo, person1a y person2 no son iguales, aunque tienen el mismo valor.

using System;

// Define a reference type that does not override Equals.
public class Person
{
   private string personName;

   public Person(string name)
   {
      this.personName = name;
   }

   public override string ToString()
   {
      return this.personName;
   }
}

public class Example
{
   public static void Main()
   {
      Person person1a = new Person("John");
      Person person1b = person1a;
      Person person2 = new Person(person1a.ToString());

      Console.WriteLine("Calling Equals:"); 
      Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b));               
      Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2));  

      Console.WriteLine("\nCasting to an Object and calling Equals:");
      Console.WriteLine("person1a and person1b: {0}", ((object) person1a).Equals((object) person1b));
      Console.WriteLine("person1a and person2: {0}", ((object) person1a).Equals((object) person2)); 
   }
}
// The example displays the following output:
//       person1a and person1b: True
//       person1a and person2: False
//       
//       Casting to an Object and calling Equals:
//       person1a and person1b: True
//       person1a and person2: False

Si la instancia actual es un tipo de valor, el método Equals(Object) pruebas de igualdad de valores. La igualdad de valores significa lo siguiente:

• Los dos objetos son del mismo tipo. Como se muestra en el ejemplo siguiente, un objeto Byte que tiene un valor de 12 no es un objeto Int32 que tiene un valor de 12, porque los dos objetos tienen distintos tipos en tiempo de ejecución.

  C#

  VB

  Copiar

  
  using System;
  
  public class Example
  {
     public static void Main()
     {
        byte value1 = 12;
        int value2 = 12;
  
        object object1 = value1;
        object object2 = value2;
  
        Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                          object1, object1.GetType().Name,
                          object2, object2.GetType().Name,
                          object1.Equals(object2));
     }
  }
  // The example displays the following output:
  //        12 (Byte) = 12 (Int32): False
  
  
  

• Los valores de los campos públicos y privados de los dos objetos son iguales. Las pruebas siguientes de ejemplo para la igualdad de valores. Define una estructura Person , que es un tipo de valor, y llama al constructor de clase Person para crear instancias de dos objetos nuevos, person1 y person2de Person , que tienen el mismo valor. Como el resultado del ejemplo, aunque las dos variables de objeto hacen referencia a distintos objetos, person1 y person2 son iguales porque tienen el mismo valor para el campo privado personName .

  C#

  VB

  Copiar

  
  using System;
  
  // Define a value type that does not override Equals.
  public struct Person
  {
     private string personName;
  
     public Person(string name)
     {
        this.personName = name;
     }
  
     public override string ToString()
     {
        return this.personName;
     }
  }
  
  public struct Example
  {
     public static void Main()
     {
        Person person1 = new Person("John");
        Person person2 = new Person("John");
  
        Console.WriteLine("Calling Equals:"); 
        Console.WriteLine(person1.Equals(person2)); 
  
        Console.WriteLine("\nCasting to an Object and calling Equals:");
        Console.WriteLine(((object) person1).Equals((object) person2));  
     }
  }
  // The example displays the following output:
  //       Calling Equals:
  //       True
  //       
  //       Casting to an Object and calling Equals:
  //       True
  
  
  

Dado que la clase Object es la clase base para todos los tipos de .NET Framework, el método Object.Equals(Object) proporciona la comparación predeterminada de igualdad para todos los demás tipos. Sin embargo, los tipos reemplazan a menudo el método Equals para implementar la igualdad de valores. Para obtener más información, vea las notas de los llamadores y notas para las secciones de los herederos.

Notas para los llamadores

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb1 = new StringBuilder("building a string...");
      StringBuilder sb2 = new StringBuilder("building a string...");

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2));
      Console.WriteLine("((Object) sb1).Equals(sb2): {0}", 
                        ((Object) sb1).Equals(sb2));
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2));      

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine("\nsb3.Equals(sb2): {0}", sb3.Equals(sb2));                              
   }
}
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False

Notas a herederos.

public class Person
{
   private string idNumber;
   private string personName;

   public Person(string name, string id)
   {
      this.personName = name;
      this.idNumber = id;
   }

   public override bool Equals(Object obj)
   {
      Person personObj = obj as Person; 
      if (personObj == null)
         return false;
      else
         return idNumber.Equals(personObj.idNumber);
   }

   public override int GetHashCode()
   {
      return this.idNumber.GetHashCode(); 
   }
}

public class Example
{
   public static void Main()
   {
      Person p1 = new Person("John", "63412895");
      Person p2 = new Person("Jack", "63412895");
      Console.WriteLine(p1.Equals(p2));
      Console.WriteLine(Object.Equals(p1, p2));
   }
}
// The example displays the following output:
//       True
//       True

El ejemplo siguiente se muestra una clase Point que invalide el método Equals para proporcionar igualdad de valor, y una clase Point3D que se deriva Point. Dado que Point reemplaza Object.Equals(Object) para comprobar la igualdad de valor, el método Object.Equals(Object) no se denomina. Sin embargo, Point3D.Equals llama Point.Equals porque Point implementa Object.Equals(Object) de una forma que proporciona la igualdad de valores.

using System;

class Point
{
   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 || this.GetType() != obj.GetType()) { 
         return false;
      }   
      else {
      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 Example 
{
  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("point3Db does not equal point2D");
     }
     if (point3Da.Equals(point3Db)) {
        Console.WriteLine("point3Da equals point3Db");
     }

  } 
}
// The example displays the following output:
//       point2D does not equal point3Da
//       point3Db does not equal point2D
//       point3Da equals point3Db

Comprueba si el método Point.Equals para asegurarse de que el argumento obj no es null y que haga referencia a una instancia del mismo tipo que este objeto. Si cualquiera de los errores activados, el método devuelve false.

Las llamadas al método Point.Equals el método GetType para determinar si los tipos en tiempo de ejecución de los dos objetos son idénticos. Si el método utilizado una comprobación del formulario obj is Point en C# o TryCast(obj, Point) en Visual Basic, la comprobación devolvería true en caso de que obj es una instancia de una clase derivada Point, aunque obj y la instancia actual no son del 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, se invoca el método heredado Point.Equals , que reemplaza Object.Equals(Object), antes de que se haga nada más. Las comprobaciones heredadas del método Point.Equals para asegurarse de que obj no es null, que obj es una instancia de la misma clase que este objeto, y que las variables de instancia heredadas. Cuando el método heredado Point.Equals vuelve true hace que el método compara 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.

El ejemplo siguiente se define una clase Rectangle que internamente implemente un rectángulo como dos objetos Point . La clase Rectangle también invalida Object.Equals(Object) para ofrecer igualdad de valor.

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 
{
  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 Example 
{
   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.");
      }
   }
}
// The example displays the following output:
//       Rectangle r1 equals rectangle r2!
//       But rectangle r2 does not equal rectangle r3.

Algunos lenguajes como sobrecarga de operadores admiten de C# y Visual Basic. Cuando un tipo sobrecarga el operador de igualdad, también debe reemplazar el método Equals(Object) para ofrecer la misma funcionalidad. Esto se consigue normalmente escribiendo el método Equals(Object) 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 tipo de valor, no puede derivarse de. Por consiguiente, la invalidación del método Equals(Object) no necesita llamar a GetType para determinar el tipo exacto del runtime de cada objeto, pero puede usar el operador is en C# o el operador TypeOf en Visual Basic para comprobar el tipo de parámetro obj .

.NET Framework

.NET Framework Client Profile

Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

Referencia