Méthode System.Object.Equals

  • Article

Cet article vous offre des remarques complémentaires à la documentation de référence pour 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 et person1b sont égales, person1a car 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: {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

    // 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("{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

      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 les notes pour les héritiers.

Remarques relatives à Windows Runtime

Lorsque vous appelez la Equals(Object) surcharge de méthode sur une classe dans Windows Runtime, elle fournit le comportement par défaut pour les classes qui ne remplacent Equals(Object)pas . 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 dans Windows Runtime n’héritent pas et n’implémentent Objectactuellement pas de Equals(Object) méthode. Toutefois, ils semblent avoir ToString, Equals(Object)et GetHashCode les 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.

Remarque

Les classes Windows Runtime écrites en C# ou Visual Basic peuvent remplacer la surcharge de méthode Equals(Object) .

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 également fréquemment une surcharge fortement typée supplémentaire à la Equals méthode, généralement en implémentant l’interface IEquatable<T> . Lorsque vous appelez la méthode pour tester l’égalité Equals , vous devez savoir si l’instance actuelle remplace Object.Equals et comprend comment un appel particulier à une Equals méthode 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 à Equals des méthodes. 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): {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

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 Objectun , lorsqu’une StringBuilder instance est affectée à une variable de type Object, et lorsque la Object.Equals(Object, Object) méthode est passée deux StringBuilder objets, 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. En 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.

Catégorie de type Égalité définie par Commentaires
Classe dérivée directement de Object Object.Equals(Object) Égalité des références ; équivalent à l’appel Object.ReferenceEquals.
Structure ValueType.Equals Égalité des valeurs ; Comparaison directe d’octets par octets ou comparaison de champ par champ à l’aide de la réflexion.
Énumération Enum.Equals Les valeurs doivent avoir le même type d’énumération et la même valeur sous-jacente.
Déléguer MulticastDelegate.Equals Les délégués doivent avoir le même type avec des listes d’appel identiques.
Interface Object.Equals(Object) Égalité des références.

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 des types référence pour tester l’égalité des Equals valeurs au lieu de l’égalité des références et définir la signification précise de 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 pour tester l’égalité Object.Equals(Object) des valeurs. Il remplace la Equals méthode de la Person classe. S’il Person accepte son implémentation de classe de base d’égalité, deux Person objets ne sont égaux que s’ils font 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

Outre la substitution Equals, vous pouvez implémenter l’interface IEquatable<T> pour fournir 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)) cette propriété est retournée true, retourne x.Equals(z)trueensuite .

  • 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 c’est nullle cas, la Equals méthode doit retourner false au lieu de lever un ArgumentNullException.

Suivez ces instructions lors de la Equals(Object)substitution :

  • 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 devez envisager d’implémenter l’interface IEquatable<T> pour prendre en charge des tests fortement typés pour l’égalité. 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 instructions suivantes s’appliquent à la Equals(Object) substitution d’un type référence :

  • Envisagez de Equals remplacer 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 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 un type de référence mutable. Cela est dû au fait que la Equals substitution nécessite que vous substituiez également la GetHashCode méthode, 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.

Instructions pour les types valeur

Les instructions suivantes s’appliquent à la Equals(Object) substitution d’un type 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 des opérateurs, vous devez surcharger l’opérateur d’égalité.

  • Vous devez implémenter l’interface IEquatable<T> . L’appel de la méthode fortement typée IEquatable<T>.Equals évite de boxer 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 les remplacements Object.Equals(Object) pour tester l’égalité des valeurs, la Object.Equals(Object) méthode n’est pas appelée. Toutefois, Point3D.Equals les appels Point.Equals parce qu’ils Point sont implémentés Object.Equals(Object) d’une manière qui fournit 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("{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));
    }
}
// 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 case activée pour vous assurer 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’un des case activée é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é un case activée du formulaire obj is Point en C# ou TryCast(obj, Point) en Visual Basic, le case activée retournerait true dans les cas où obj est 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 effectue obj un cast 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 (NotInheritableen Visual Basic), un case activée dans le formulaire obj is Point en C# ou TryCast(obj, Point) en Visual Basic est suffisant 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("{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));
   }
}
// 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("{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));
  }
}
// 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 substitution à Equals(Object) la méthode n’a pas besoin d’appeler GetType pour déterminer le type d’exécution précis de chaque objet, mais peut utiliser l’opérateur is en C# ou l’opérateur TypeOf en Visual Basic pour case activée le type du obj paramètre.