Object.Equals, méthode (Object)

Le type de comparaison entre l'instance actuelle et le paramètre d' obj dépend si l'instance actuelle est un type référence ou un type valeur. Si l'instance actuelle est un type référence, la méthode d' Equals(Object) détermine l'égalité des références, et un appel à la méthode d' Equals(Object) équivaut à un appel à la méthode d' ReferenceEquals . L'égalité des références signifie que les variables objets qui sont comparées font référence au même objet. L'exemple suivant montre le résultat de cette comparaison. Il définit une classe d' Person , qui est un type référence, puis appelle le constructeur de classe d' Person pour instancier deux nouveaux objets, person1a et person2d' Person , qui ont la même valeur. Il assigne également person1a à une autre variable objet, person1b. Comme la sortie de l'exemple indique, person1a et person1b sont égaux parce qu'ils référencent le même objet. Toutefois, person1a et person2 ne sont pas identiques, bien qu'ils ont la même valeur.

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 l'instance actuelle est un type valeur, la méthode d' Equals(Object) détermine l'égalité des valeurs. L'égalité des valeurs signifie ce qui suit :

• Les deux objets sont du même type. Comme le montre l'exemple suivant, un objet d' Byte qui a la valeur 12 n'est pas un objet d' Int32 qui a la valeur 12, car les deux objets ont différents types d'exécution.

  C#

  VB

  Copier

  
  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
  
  
  

• Les valeurs des champs publics et privés les deux objets sont égaux. L'exemple suivant teste d'égalité des valeurs. Elle définit une structure d' Person , qui est un type valeur, et appelle le constructeur de classe d' Person pour instancier deux nouveaux objets, person1 et person2d' Person , qui ont la même valeur. Comme la sortie de l'exemple, bien que les deux variables objets font référence à des objets, person1 et person2 sont égale car ils ont la même valeur pour le champ privé d' personName .

  C#

  VB

  Copier

  
  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
  
  
  

Étant donné que la classe d' Object est la classe de base pour le tous les types .NET Framework, la méthode d' Object.Equals(Object) fournit la comparaison d'égalité par défaut pour tous les autres types. Toutefois, les types substituent souvent la méthode d' Equals pour implémenter l'égalité des valeurs. Pour plus d'informations, consultez les remarques pour les appelants et les remarques pour les sections de héritiers.

Remarques relatives aux appelants

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

Remarques à l'attention des héritiers

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

L'exemple suivant illustre une classe d' Point qui substitue la méthode d' Equals pour fournir l'égalité des valeurs, et une classe d' Point3D dérivée d' Point. Étant donné qu' Point remplace Object.Equals(Object) pour déterminer l'égalité des valeurs, la méthode d' Object.Equals(Object) n'est pas appelée. Toutefois, Point3D.Equals appelle Point.Equals car Point implémente Object.Equals(Object) d'une manière qui fournit l'égalité des valeurs.

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

La méthode d' Point.Equals vérifie que l'argument d' obj n'est pas null et qu'il référence une instance du même type que cet objet. Si l'un ou l'autre contrôle échoue, la méthode retourne false.

Les appels de méthode d' Point.Equals la méthode d' GetType pour déterminer si les types d'exécution des deux objets sont identiques. Si la méthode a utilisé un contrôle du formulaire obj is Point en C# ou d' TryCast(obj, Point) en Visual Basic, le contrôle retourne true dans les cas où obj est une instance d'une classe dérivée d' Point, même si obj et l'instance actuelle ne soient pas du même type d'exécution. Après avoir vérifié que les deux objets sont du même type, la méthode effectue un cast de obj en type Point et retourne le résultat de la comparaison des variables de l'instance des deux objets.

Dans Point3D.Equals, la méthode héritée d' Point.Equals , qui remplace Object.Equals(Object), est appelée avant que tout autre élément soit effectué. La méthode héritée d' Point.Equals contrôle pour vous assurer qu' obj n'est pas null, qu' obj est une instance de la même classe que cet objet, et que les variables d'instance héritées correspondent. Uniquement lorsque la méthode héritée d' Point.Equals retourne true fait la méthode comparent les variables d'instance introduites dans la classe dérivée. En particulier, le cast en Point3D n'est pas exécuté, à moins que obj ait été défini comme étant de type Point3D ou une classe dérivée de Point3D.

L'exemple suivant définit une classe d' Rectangle qui implémente en interne un rectangle comme deux objets d' Point . La classe d' Rectangle substitue également Object.Equals(Object) prévoir l'égalité des valeurs.

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.

Certains langages tels que C# et Visual Basic prennent en charge la surcharge d'opérateur. Si un type surcharge l'opérateur d'égalité, il doit également substituer la méthode Equals(Object) pour fournir les mêmes fonctionnalités. En général, ceci est réalisé en écrivant la méthode Equals(Object) sous la forme de l'opérateur d'égalité surchargé, comme dans l'exemple de code suivant.

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!

Étant donné qu' Complex est un type valeur, il ne peut pas être dérivé de. Par conséquent, la substitution de la méthode d' Equals(Object) n'a pas besoin d'appeler GetType pour déterminer le type d'exécution exact de chaque objet, mais peut utiliser à la place l'opérateur d' is en C# ou l'opérateur d' TypeOf en Visual Basic pour contrôler le type du paramètre d' obj .

.NET Framework

.NET Framework Client Profile

Bibliothèque de classes portable

.NET pour les applications du Windows Store

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Référence