Méthode System.Object.Equals

Cet article fournit des remarques supplémentaires à la documentation de référence de cette API.

Cet article concerne la Object.Equals(Object) méthode.

Le type de comparaison entre l’instance actuelle et le obj paramètre varie selon que l’instance actuelle est un type référence ou un type valeur.

• Si l’instance actuelle est un type de référence, la méthode teste l’égalité Equals(Object) de référence et un appel à la Equals(Object) méthode équivaut à un appel à la ReferenceEquals méthode. L’égalité de référence signifie que les variables d’objet comparées font référence au même objet. L’exemple suivant illustre le résultat d’une telle comparaison. Il définit une Person classe, qui est un type de référence, et appelle le Person constructeur de classe pour instancier deux nouveaux Person objets, person1a et person2qui ont la même valeur. Il affecte person1a également à une autre variable d’objet. person1b Comme le montre la sortie de l’exemple, person1a et person1b sont égaux parce qu'ils référencent le même objet. Toutefois, person1a et person2 ne sont pas égaux, bien qu’ils aient 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 Example1
  {
     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: {person1a.Equals(person1b)}");
        Console.WriteLine($"person1a and person2: {person1a.Equals(person2)}");
  
        Console.WriteLine("\nCasting to an Object and calling Equals:");
        Console.WriteLine($"person1a and person1b: {((object) person1a).Equals((object) person1b)}");
        Console.WriteLine($"person1a and person2: {((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
  

  // Define a reference type that does not override Equals.
  type Person(name) =
      override _.ToString() =
          name
  
  let person1a = Person "John"
  let person1b = person1a
  let person2 = Person(string person1a)
  
  printfn "Calling Equals:"
  printfn $"person1a and person1b: {person1a.Equals person1b}"
  printfn $"person1a and person2: {person1a.Equals person2}"
  
  printfn "\nCasting to an Object and calling Equals:"
  printfn $"person1a and person1b: {(person1a :> obj).Equals(person1b :> obj)}"
  printfn $"person1a and person2: {(person1a :> obj).Equals(person2 :> obj)}"
  // 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
  

  ' Define a reference type that does not override Equals.
  Public Class Person1
      Private personName As String
  
      Public Sub New(name As String)
          Me.personName = name
      End Sub
  
      Public Overrides Function ToString() As String
          Return Me.personName
      End Function
  End Class
  
  Module Example0
      Public Sub Main()
          Dim person1a As New Person1("John")
          Dim person1b As Person1 = person1a
          Dim person2 As New Person1(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()
  
          Console.WriteLine("Casting to an Object and calling Equals:")
          Console.WriteLine("person1a and person1b: {0}", CObj(person1a).Equals(CObj(person1b)))
          Console.WriteLine("person1a and person2: {0}", CObj(person1a).Equals(CObj(person2)))
      End Sub
  End Module
  ' The example displays the following output:
  '       Calling Equals:
  '       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 teste l’égalité Equals(Object) des valeurs. L’égalité des valeurs signifie ce qui suit :

  • Les deux objets sont du même type. Comme l’illustre l’exemple suivant, un Byte objet dont la valeur est 12 n’est pas égale à un Int32 objet dont la valeur est 12, car les deux objets ont des types d’exécution différents.

    byte value1 = 12;
    int value2 = 12;
    
    object object1 = value1;
    object object2 = value2;
    
    Console.WriteLine($"{object1} ({object1.GetType().Name}) = {object2} ({object2.GetType().Name}): {object1.Equals(object2)}");
    
    // The example displays the following output:
    //        12 (Byte) = 12 (Int32): False
    

    let value1 = 12uy
    let value2 = 12
    
    let object1 = value1 :> obj
    let object2 = value2 :> obj
    
    printfn $"{object1} ({object1.GetType().Name}) = {object2} ({object2.GetType().Name}): {object1.Equals object2}"
    
    // The example displays the following output:
    //        12 (Byte) = 12 (Int32): False
    

    Module Example2
        Public Sub Main()
            Dim value1 As Byte = 12
            Dim value2 As Integer = 12
    
            Dim object1 As Object = value1
            Dim object2 As Object = value2
    
            Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                            object1, object1.GetType().Name,
                            object2, object2.GetType().Name,
                            object1.Equals(object2))
        End Sub
    End Module
    ' The example displays the following output:
    '       12 (Byte) = 12 (Int32): False
    

  • Les valeurs des champs publics et privés des deux objets sont égales. L’exemple suivant teste l’égalité des valeurs. Il définit une Person structure, qui est un type valeur, et appelle le Person constructeur de classe pour instancier deux nouveaux Person objets, person1 et person2, qui ont la même valeur. Comme le montre la sortie de l’exemple, même si les deux variables d’objet font référence à différents objets et person1person2 sont égales, car elles ont la même valeur pour le champ privé personName .

    using System;
    
    // Define a value type that does not override Equals.
    public struct Person3
    {
       private string personName;
    
       public Person3(string name)
       {
          this.personName = name;
       }
    
       public override string ToString()
       {
          return this.personName;
       }
    }
    
    public struct Example3
    {
       public static void Main()
       {
          Person3 person1 = new Person3("John");
          Person3 person2 = new Person3("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
    

    // Define a value type that does not override Equals.
    [<Struct>]
    type Person(personName: string) =
        override _.ToString() =
            personName
    
    let person1 = Person "John"
    let person2 = Person "John"
    
    printfn "Calling Equals:"
    printfn $"{person1.Equals person2}"
    
    printfn $"\nCasting to an Object and calling Equals:"
    printfn $"{(person1 :> obj).Equals(person2 :> obj)}"
    // The example displays the following output:
    //       Calling Equals:
    //       True
    //
    //       Casting to an Object and calling Equals:
    //       True
    

    ' Define a value type that does not override Equals.
    Public Structure Person4
        Private personName As String
    
        Public Sub New(name As String)
            Me.personName = name
        End Sub
    
        Public Overrides Function ToString() As String
            Return Me.personName
        End Function
    End Structure
    
    Module Example4
        Public Sub Main()
            Dim p1 As New Person4("John")
            Dim p2 As New Person4("John")
    
            Console.WriteLine("Calling Equals:")
            Console.WriteLine(p1.Equals(p2))
            Console.WriteLine()
    
            Console.WriteLine("Casting to an Object and calling Equals:")
            Console.WriteLine(CObj(p1).Equals(p2))
        End Sub
    End Module
    ' The example displays the following output:
    '       Calling Equals:
    '       True
    '       
    '       Casting to an Object and calling Equals:
    '       True
    

Étant donné que la Object classe est la classe de base pour tous les types dans .NET, la Object.Equals(Object) méthode fournit la comparaison d’égalité par défaut pour tous les autres types. Toutefois, les types remplacent souvent la méthode pour implémenter l’égalité Equals des valeurs. Pour plus d’informations, consultez les sections Notes pour les Appelants et Notes pour les Héritiers.

Remarques relatives à Windows Runtime

Lorsque vous appelez la surcharge de la méthode Equals(Object) sur une classe dans Windows Runtime, elle fournit le comportement par défaut pour les classes qui ne remplacent pas Equals(Object). Cela fait partie de la prise en charge que .NET fournit pour Windows Runtime (voir prise en charge de .NET pour les applications du Windows Store et Windows Runtime). Les classes de Windows Runtime ne dérivent d'aucune classe Object, et actuellement, elles n'implémentent aucune méthode Equals(Object). Toutefois, ils semblent avoir ToString, Equals(Object), et GetHashCode méthodes lorsque vous les utilisez dans votre code C# ou Visual Basic, et .NET fournit le comportement par défaut pour ces méthodes.

Remarques pour les appelants

Les classes dérivées remplacent fréquemment la méthode pour implémenter l’égalité Object.Equals(Object) des valeurs. En outre, les types fournissent aussi fréquemment une surcharge fortement typée supplémentaire à la méthode Equals, généralement en implémentant l’interface IEquatable<T>. Lorsque vous appelez la méthode Equals pour tester l’égalité, vous devez savoir si l’instance actuelle redéfinit Object.Equals et comprendre comment un appel particulier à une méthode Equals est résolu. Sinon, vous pouvez effectuer un test d’égalité différent de celui que vous avez prévu et la méthode peut retourner une valeur inattendue.

L'exemple suivant illustre cette situation. Il instancie trois StringBuilder objets avec des chaînes identiques, puis effectue quatre appels aux méthodes Equals. Le premier appel de méthode retourne true, et les trois autres retours false.

using System;
using System.Text;

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

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

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine($"\nsb3.Equals(sb2): {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

open System
open System.Text

let sb1 = StringBuilder "building a string..."
let sb2 = StringBuilder "building a string..."

printfn $"sb1.Equals(sb2): {sb1.Equals sb2}"
printfn $"((Object) sb1).Equals(sb2): {(sb1 :> obj).Equals sb2}"
                  
printfn $"Object.Equals(sb1, sb2): {Object.Equals(sb1, sb2)}"

let sb3 = StringBuilder "building a string..."
printfn $"\nsb3.Equals(sb2): {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

Imports System.Text

Module Example5
    Public Sub Main()
        Dim sb1 As New StringBuilder("building a string...")
        Dim sb2 As New StringBuilder("building a string...")

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

        Console.WriteLine()
        Dim sb3 As Object = New StringBuilder("building a string...")
        Console.WriteLine("sb3.Equals(sb2): {0}", sb3.Equals(sb2))
    End Sub
End Module
' The example displays the following output:
'       sb1.Equals(sb2): True
'       CObj(sb1).Equals(sb2): False
'       Object.Equals(sb1, sb2): False
'
'       sb3.Equals(sb2): False

Dans le premier cas, la surcharge de méthode fortement typée StringBuilder.Equals(StringBuilder), qui teste l’égalité des valeurs, est appelée. Étant donné que les chaînes affectées aux deux StringBuilder objets sont égales, la méthode retourne true. Toutefois, StringBuilder ne remplace Object.Equals(Object)pas . En raison de cela, lorsque l'objet StringBuilder est converti en Object, lorsqu'une instance StringBuilder est assignée à une variable de type Object, et lorsque la méthode Object.Equals(Object, Object) reçoit deux objets StringBuilder, la méthode par défaut Object.Equals(Object) est appelée. Étant donné qu’il StringBuilder s’agit d’un type référence, cela équivaut à transmettre les deux StringBuilder objets à la ReferenceEquals méthode. Bien que les trois StringBuilder objets contiennent des chaînes identiques, ils font référence à trois objets distincts. Par conséquent, ces trois appels de méthode retournent false.

Vous pouvez comparer l’objet actuel à un autre objet pour l’égalité de référence en appelant la ReferenceEquals méthode. Dans Visual Basic, vous pouvez également utiliser le is mot clé (par exemple, If Me Is otherObject Then ...).

Remarques pour les héritiers

Lorsque vous définissez votre propre type, ce type hérite des fonctionnalités définies par la Equals méthode de son type de base. Le tableau suivant répertorie l’implémentation par défaut de la Equals méthode pour les principales catégories de types dans .NET.

Pour un type valeur, vous devez toujours remplacer Equals, car les tests d’égalité qui s’appuient sur la réflexion offrent des performances médiocres. Vous pouvez également remplacer l’implémentation par défaut de Equals pour les types référence afin de tester l'égalité des valeurs plutôt que l'égalité des références et de définir précisément ce que signifie l’égalité des valeurs. Ces implémentations de Equals retour true si les deux objets ont la même valeur, même s’ils ne sont pas la même instance. L’implémenteur du type détermine ce qui constitue la valeur d’un objet, mais il s’agit généralement d’une partie ou de toutes les données stockées dans les variables d’instance de l’objet. Par exemple, la valeur d’un String objet est basée sur les caractères de la chaîne ; la String.Equals(Object) méthode remplace la Object.Equals(Object) méthode pour retourner true pour deux instances de chaîne qui contiennent les mêmes caractères dans le même ordre.

L’exemple suivant montre comment remplacer la méthode Object.Equals(Object) pour tester l’égalité des valeurs. Il remplace la Equals méthode de la Person classe. Si Person acceptait son implémentation de classe de base relative à l’égalité, deux Person objets seraient égaux uniquement s’ils faisaient référence à un seul objet. Toutefois, dans ce cas, deux Person objets sont égaux s’ils ont la même valeur pour la Person.Id propriété.

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

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

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

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

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

open System

type Person(name, id) =
    member _.Name = name
    member _.Id = id

    override _.Equals(obj) =
        match obj with
        | :? Person as personObj ->
            id.Equals personObj.Id
        | _ -> 
            false

    override _.GetHashCode() =
        id.GetHashCode()

let p1 = Person("John", "63412895")
let p2 = Person("Jack", "63412895")
printfn $"{p1.Equals p2}"
printfn $"{Object.Equals(p1, p2)}"
// The example displays the following output:
//       True
//       True

Public Class Person
   Private idNumber As String
   Private personName As String
   
   Public Sub New(name As String, id As String)
      Me.personName = name
      Me.idNumber = id
   End Sub
   
   Public Overrides Function Equals(obj As Object) As Boolean
      Dim personObj As Person = TryCast(obj, Person) 
      If personObj Is Nothing Then
         Return False
      Else
         Return idNumber.Equals(personObj.idNumber)
      End If   
   End Function
   
   Public Overrides Function GetHashCode() As Integer
      Return Me.idNumber.GetHashCode() 
   End Function
End Class

Module Example6
    Public Sub Main()
        Dim p1 As New Person("John", "63412895")
        Dim p2 As New Person("Jack", "63412895")
        Console.WriteLine(p1.Equals(p2))
        Console.WriteLine(Object.Equals(p1, p2))
    End Sub
End Module
' The example displays the following output:
'       True
'       True

En plus de remplacer Equals, vous pouvez implémenter l’interface IEquatable<T> pour offrir un test fortement typé pour l’égalité.

Les instructions suivantes doivent être vraies pour toutes les implémentations de la Equals(Object) méthode. Dans la liste, x, yet z représentent les références d’objet qui ne sont pas null.

• x.Equals(x) retourne true.

• x.Equals(y) retourne la même valeur que y.Equals(x).

• x.Equals(y) retourne true si les deux x et y sont NaN.

• Si (x.Equals(y) && y.Equals(z)) retourne true, alors x.Equals(z) retourne true.

• Appels successifs pour x.Equals(y) retourner la même valeur tant que les objets référencés par x et y ne sont pas modifiés.

• x.Equals(null) retourne false.

Les implémentations de Equals ne doivent pas lever d’exceptions ; elles doivent toujours retourner une valeur. Par exemple, si obj est null, la méthode Equals doit retourner false au lieu de lever une ArgumentNullException.

Suivez ces instructions lors du remplacement de Equals(Object) :

• Les types qui implémentent IComparable doivent remplacer Equals(Object).

• Les types qui remplacent Equals(Object) doivent également remplacer GetHashCode; sinon, les tables de hachage peuvent ne pas fonctionner correctement.

• Vous devriez envisager d’implémenter l’interface IEquatable<T> pour prendre en charge des tests d’égalité fortement typés. Votre implémentation de IEquatable<T>.Equals doit retourner des résultats cohérents avec Equals.

• Si votre langage de programmation prend en charge la surcharge des opérateurs et que vous surchargez l’opérateur d’égalité pour un type donné, vous devez également remplacer la Equals(Object) méthode pour retourner le même résultat que l’opérateur d’égalité. Cela permet de garantir que le code de bibliothèque de classes qui utilise Equals (par exemple ArrayList et Hashtable) se comporte de manière cohérente avec la façon dont l’opérateur d’égalité est utilisé par le code d’application.

Instructions pour les types de référence

Les directives suivantes s’appliquent au remplacement de Equals(Object) pour un type de référence :

• Envisagez de remplacer Equals si la sémantique du type est basée sur le fait que le type représente une ou plusieurs valeurs.

• La plupart des types de référence ne doivent pas surcharger l’opérateur d’égalité, même s’ils remplacent Equals. Toutefois, si vous implémentez un type référence destiné à avoir une sémantique de valeur, comme un type de nombre complexe, vous devez remplacer l’opérateur d’égalité.

• Vous ne devez pas remplacer Equals par un type de référence mutable. Cela est dû au fait que la redéfinition de Equals nécessite également que vous redéfinissiez la méthode GetHashCode, comme indiqué dans la section précédente. Cela signifie que le code de hachage d’une instance d’un type de référence mutable peut changer pendant sa durée de vie, ce qui peut entraîner la perte de l’objet dans une table de hachage.

Directives pour les types de valeurs

Les directives suivantes s’appliquent au remplacement de Equals(Object) pour un type de valeur :

• Si vous définissez un type valeur qui inclut un ou plusieurs champs dont les valeurs sont des types de référence, vous devez remplacer Equals(Object). L’implémentation Equals(Object) fournie par ValueType effectue une comparaison d’octets par octets pour les types valeur dont les champs sont tous les types valeur, mais elle utilise la réflexion pour effectuer une comparaison de champs par champ de types valeur dont les champs incluent des types référence.

• Si vous remplacez Equals et que votre langage de développement prend en charge la surcharge d’opérateur, vous devez redéfinir l’opérateur d’égalité.

• Vous devez implémenter l’interface IEquatable<T> . L’appel de la méthode IEquatable<T>.Equals fortement typée évite le boxing de l’argument obj.

Exemples

L’exemple suivant montre une Point classe qui remplace la Equals méthode pour fournir l’égalité des valeurs et une Point3D classe dérivée de Point. Étant donné que Point remplace Object.Equals(Object) pour tester l’égalité des valeurs, la méthode Object.Equals(Object) n’est pas appelée. Toutefois, Point3D.Equals appelle Point.Equals parce que Point est implémenté Object.Equals(Object) d'une manière qui garantit l'égalité des valeurs.

using System;

class Point2
{
    protected int x, y;

    public Point2() : this(0, 0)
    { }

    public Point2(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().Equals(obj.GetType()))
        {
            return false;
        }
        else
        {
            Point2 p = (Point2)obj;
            return (x == p.x) && (y == p.y);
        }
    }

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

    public override string ToString()
    {
        return String.Format("Point2({0}, {1})", x, y);
    }
}

sealed class Point3D : Point2
{
    int z;

    public Point3D(int x, int y, int z) : base(x, y)
    {
        this.z = z;
    }

    public override bool Equals(Object obj)
    {
        Point3D pt3 = obj as Point3D;
        if (pt3 == null)
            return false;
        else
            return base.Equals((Point2)obj) && z == pt3.z;
    }

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

    public override String ToString()
    {
        return String.Format("Point2({0}, {1}, {2})", x, y, z);
    }
}

class Example7
{
    public static void Main()
    {
        Point2 point2D = new Point2(5, 5);
        Point3D point3Da = new Point3D(5, 5, 2);
        Point3D point3Db = new Point3D(5, 5, 2);
        Point3D point3Dc = new Point3D(5, 5, -1);

        Console.WriteLine($"{point2D} = {point3Da}: {point2D.Equals(point3Da)}");
        Console.WriteLine($"{point2D} = {point3Db}: {point2D.Equals(point3Db)}");
        Console.WriteLine($"{point3Da} = {point3Db}: {point3Da.Equals(point3Db)}");
        Console.WriteLine($"{point3Da} = {point3Dc}: {point3Da.Equals(point3Dc)}");
    }
}
// The example displays the following output:
//       Point2(5, 5) = Point2(5, 5, 2): False
//       Point2(5, 5) = Point2(5, 5, 2): False
//       Point2(5, 5, 2) = Point2(5, 5, 2): True
//       Point2(5, 5, 2) = Point2(5, 5, -1): False

type Point(x, y) =
    new () = Point(0, 0)
    member _.X = x
    member _.Y = y

    override _.Equals(obj) =
        //Check for null and compare run-time types.
        match obj with
        | :? Point as p ->
            x = p.X && y = p.Y
        | _ -> 
            false

    override _.GetHashCode() =
        (x <<< 2) ^^^ y

    override _.ToString() =
        $"Point({x}, {y})"

type Point3D(x, y, z) =
    inherit Point(x, y)
    member _.Z = z

    override _.Equals(obj) =
        match obj with
        | :? Point3D as pt3 ->
            base.Equals(pt3 :> Point) && z = pt3.Z
        | _ -> 
            false

    override _.GetHashCode() =
        (base.GetHashCode() <<< 2) ^^^ z

    override _.ToString() =
        $"Point({x}, {y}, {z})"

let point2D = Point(5, 5)
let point3Da = Point3D(5, 5, 2)
let point3Db = Point3D(5, 5, 2)
let point3Dc = Point3D(5, 5, -1)

printfn $"{point2D} = {point3Da}: {point2D.Equals point3Da}"
printfn $"{point2D} = {point3Db}: {point2D.Equals point3Db}"
printfn $"{point3Da} = {point3Db}: {point3Da.Equals point3Db}"
printfn $"{point3Da} = {point3Dc}: {point3Da.Equals point3Dc}"
// The example displays the following output:
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5, 2) = Point(5, 5, 2): True
//       Point(5, 5, 2) = Point(5, 5, -1): False

Class Point1
    Protected x, y As Integer

    Public Sub New()
        Me.x = 0
        Me.y = 0
    End Sub

    Public Sub New(x As Integer, y As Integer)
        Me.x = x
        Me.y = y
    End Sub

    Public Overrides Function Equals(obj As Object) As Boolean
        ' Check for null and compare run-time types.
        If obj Is Nothing OrElse Not Me.GetType().Equals(obj.GetType()) Then
            Return False
        Else
            Dim p As Point1 = DirectCast(obj, Point1)
            Return x = p.x AndAlso y = p.y
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return (x << 2) Xor y
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point1({0}, {1})", x, y)
    End Function
End Class

Class Point3D : Inherits Point1
    Private z As Integer

    Public Sub New(ByVal x As Integer, ByVal y As Integer, ByVal z As Integer)
        MyBase.New(x, y)
        Me.z = z
    End Sub

    Public Overrides Function Equals(ByVal obj As Object) As Boolean
        Dim pt3 As Point3D = TryCast(obj, Point3D)
        If pt3 Is Nothing Then
            Return False
        Else
            Return MyBase.Equals(CType(pt3, Point1)) AndAlso z = pt3.z
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return (MyBase.GetHashCode() << 2) Xor z
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point1({0}, {1}, {2})", x, y, z)
    End Function
End Class

Module Example1
    Public Sub Main()
        Dim point2D As New Point1(5, 5)
        Dim point3Da As New Point3D(5, 5, 2)
        Dim point3Db As New Point3D(5, 5, 2)
        Dim point3Dc As New Point3D(5, 5, -1)

        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Da, point2D.Equals(point3Da))
        Console.WriteLine("{0} = {1}: {2}",
                          point2D, point3Db, point2D.Equals(point3Db))
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Db, point3Da.Equals(point3Db))
        Console.WriteLine("{0} = {1}: {2}",
                          point3Da, point3Dc, point3Da.Equals(point3Dc))
    End Sub
End Module
' The example displays the following output
'       Point1(5, 5) = Point1(5, 5, 2): False
'       Point1(5, 5) = Point1(5, 5, 2): False
'       Point1(5, 5, 2) = Point1(5, 5, 2): True
'       Point1(5, 5, 2) = Point1(5, 5, -1): False

La Point.Equals méthode vérifie que l’argument obj n’est pas null et qu’il fait référence à une instance du même type que cet objet. Si l’une ou l’autre vérification échoue, la méthode retourne false.

La Point.Equals méthode appelle la GetType méthode pour déterminer si les types d’exécution des deux objets sont identiques. Si la méthode a utilisé une vérification du formulaire obj is Point en C# ou TryCast(obj, Point) en Visual Basic, la vérification retourne true dans les cas où obj il s’agit d’une instance d’une classe dérivée de Point, même si obj et l’instance actuelle ne sont 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 convertit obj en type Point et retourne le résultat de la comparaison des champs d’instance des deux objets.

Dans Point3D.Equals, la méthode héritée Point.Equals , qui remplace Object.Equals(Object), est appelée avant toute autre opération. Étant donné qu’il Point3D s’agit d’une classe sealed (NotInheritable en Visual Basic), une vérification dans le formulaire obj is Point en C# ou TryCast(obj, Point) en Visual Basic est suffisante pour s’assurer qu’il s’agit obj d’un Point3D objet. S’il s’agit d’un Point3D objet, il est converti en objet Point et transmis à l’implémentation de classe de base de Equals. Uniquement lorsque la méthode héritée Point.Equals retourne true la méthode compare les z champs d’instance introduits dans la classe dérivée.

L’exemple suivant définit une Rectangle classe qui implémente en interne un rectangle sous la forme de deux Point objets. La Rectangle classe remplace Object.Equals(Object) également pour fournir l’égalité des valeurs.

using System;

class Rectangle
{
   private 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)
   {
      // Perform an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType())
          return false;
      Rectangle r = (Rectangle)obj;
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode()
   {
      return Tuple.Create(a, b).GetHashCode();
   }

    public override String ToString()
    {
       return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y);
    }
}

class Point
{
  internal int x;
  internal 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 Tuple.Create(x, 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);

      Console.WriteLine($"{r1} = {r2}: {r1.Equals(r2)}");
      Console.WriteLine($"{r1} = {r3}: {r1.Equals(r3)}");
      Console.WriteLine($"{r2} = {r3}: {r2.Equals(r3)}");
   }
}
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

type Point(x, y) =
    member _.X = x
    member _.Y = y

    override _.Equals(obj) =
        // Performs an equality check on two points (integer pairs).
        match obj with
        | :? Point as p ->
            x = p.X && y = p.Y
        | _ ->
            false
    
    override _.GetHashCode() =
        (x, y).GetHashCode()

type Rectangle(upLeftX, upLeftY, downRightX, downRightY) =
    let a = Point(upLeftX, upLeftY)
    let b = Point(downRightX, downRightY)
    
    member _.UpLeft = a
    member _.DownRight = b

    override _.Equals(obj) =
        // Perform an equality check on two rectangles (Point object pairs).
        match obj with
        | :? Rectangle as r ->
            a.Equals(r.UpLeft) && b.Equals(r.DownRight)
        | _ -> 
            false
        
    override _.GetHashCode() =
        (a, b).GetHashCode()

    override _.ToString() =
       $"Rectangle({a.X}, {a.Y}, {b.X}, {b.Y})"

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

printfn $"{r1} = {r2}: {r1.Equals r2}"
printfn $"{r1} = {r3}: {r1.Equals r3}"
printfn $"{r2} = {r3}: {r2.Equals r3}"
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

Class Rectangle 
    Private a, b As Point
    
    Public Sub New(ByVal upLeftX As Integer, ByVal upLeftY As Integer, _
                   ByVal downRightX As Integer, ByVal downRightY As Integer) 
        Me.a = New Point(upLeftX, upLeftY)
        Me.b = New Point(downRightX, downRightY)
    End Sub 
    
    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two rectangles (Point object pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        End If
        Dim r As Rectangle = CType(obj, Rectangle)
        Return a.Equals(r.a) AndAlso b.Equals(r.b)
    End Function

    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(a, b).GetHashCode()
    End Function 

    Public Overrides Function ToString() As String
       Return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y) 
    End Function
End Class 

Class Point
    Friend x As Integer
    Friend y As Integer
    
    Public Sub New(ByVal X As Integer, ByVal Y As Integer) 
        Me.x = X
        Me.y = Y
    End Sub 

    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two points (integer pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        Else
           Dim p As Point = CType(obj, Point)
           Return x = p.x AndAlso y = p.y
        End If
    End Function 
    
    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(x, y).GetHashCode()
    End Function 
End Class  

Class Example
    Public Shared Sub Main() 
        Dim r1 As New Rectangle(0, 0, 100, 200)
        Dim r2 As New Rectangle(0, 0, 100, 200)
        Dim r3 As New Rectangle(0, 0, 150, 200)
        
        Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2))
        Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3))
        Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3))
    End Sub 
End Class 
' The example displays the following output:
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

Certains langages tels que C# et Visual Basic prennent en charge la surcharge des opérateurs. Lorsqu’un type surcharge l’opérateur d’égalité, il doit également remplacer la Equals(Object) méthode pour fournir la même fonctionnalité. Cela s’effectue généralement en écrivant la Equals(Object) méthode en termes d’opérateur d’égalité surchargé, comme dans l’exemple 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 Tuple.Create(re, 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);
   }

    public override String ToString()
    {
       return String.Format("({0}, {1})", re, im);
    }
}

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;

    Console.WriteLine($"{cmplx1} <> {cmplx2}: {cmplx1 != cmplx2}");
    Console.WriteLine($"{cmplx1} = {cmplx2}: {cmplx1.Equals(cmplx2)}");

    cmplx2.re = 4.0;

    Console.WriteLine($"{cmplx1} = {cmplx2}: {cmplx1 == cmplx2}");
    Console.WriteLine($"{cmplx1} = {cmplx2}: {cmplx1.Equals(cmplx2)}");
  }
}
// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True

[<Struct; CustomEquality; NoComparison>]
type Complex =
    val mutable re: double
    val mutable im: double

    override this.Equals(obj) =
        match obj with 
        | :? Complex as c when c = this -> true
        | _ -> false 

    override this.GetHashCode() =
        (this.re, this.im).GetHashCode()

    override this.ToString() =
        $"({this.re}, {this.im})"

    static member op_Equality (x: Complex, y: Complex) =
        x.re = y.re && x.im = y.im

    static member op_Inequality (x: Complex, y: Complex) =
        x = y |> not

let mutable cmplx1 = Complex()
let mutable cmplx2 = Complex()

cmplx1.re <- 4.0
cmplx1.im <- 1.0

cmplx2.re <- 2.0
cmplx2.im <- 1.0

printfn $"{cmplx1} <> {cmplx2}: {cmplx1 <> cmplx2}"
printfn $"{cmplx1} = {cmplx2}: {cmplx1.Equals cmplx2}"

cmplx2.re <- 4.0

printfn $"{cmplx1} = {cmplx2}: {cmplx1 = cmplx2}"
printfn $"{cmplx1} = {cmplx2}: {cmplx1.Equals cmplx2}"

// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True

Public Structure Complex
    Public re, im As Double
    
    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        Return TypeOf obj Is Complex AndAlso Me = CType(obj, Complex)
    End Function 
    
    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(re, im).GetHashCode()
    End Function 
    
    Public Shared Operator = (x As Complex, y As Complex) As Boolean
       Return x.re = y.re AndAlso x.im = y.im
    End Operator 
    
    Public Shared Operator <> (x As Complex, y As Complex) As Boolean
       Return Not (x = y)
    End Operator 
    
    Public Overrides Function ToString() As String
       Return String.Format("({0}, {1})", re, im)
    End Function 
End Structure

Class Example8
    Public Shared Sub Main()
        Dim cmplx1, cmplx2 As Complex

        cmplx1.re = 4.0
        cmplx1.im = 1.0

        cmplx2.re = 2.0
        cmplx2.im = 1.0

        Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 <> cmplx2)
        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))

        cmplx2.re = 4.0

        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 = cmplx2)
        Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))
    End Sub
End Class
' The example displays the following output:
'       (4, 1) <> (2, 1): True
'       (4, 1) = (2, 1): False
'       (4, 1) = (4, 1): True
'       (4, 1) = (4, 1): True

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