Object.Equals Méthode

Définition

Détermine si les deux instances d'objet sont égales.

Surcharges

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

Equals(Object, Object)

Détermine si les instances d'objet spécifiées sont considérées comme égales.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

public:
 virtual bool Equals(System::Object ^ obj);
public virtual bool Equals (object obj);
public virtual bool Equals (object? obj);
abstract member Equals : obj -> bool
override this.Equals : obj -> bool
Public Overridable Function Equals (obj As Object) As Boolean

Paramètres

obj
Object

Objet à comparer à l'objet actuel.

Retours

Boolean

true si l’objet spécifié est égal à l’objet actuel ; sinon, false.

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) de manière à fournir l’égalité des valeurs.

using System;

class Point
{
   protected int x, y;

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

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

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

sealed class Point3D: Point
{
   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((Point)obj) && z == pt3.z;
   }

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

   public override String ToString()
   {
        return String.Format("Point({0}, {1}, {2})", x, y, 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);
     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:
//       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
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 Point
    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 Point = DirectCast(obj, Point)
           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("Point({0}, {1})", x, y)
    End Function
End Class

Class Point3D : Inherits Point
    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, Point)) 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("Point({0}, {1}, {2})", x, y, z)
    End Function
End Class 

Module Example
    Public Sub Main() 
        Dim point2D As New Point(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
'       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

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 des vérifications é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) dans Visual Basic, la vérification retourne 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 de même type, la méthode est castée 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 tout autre chose. Étant donné qu’il Point3D s’agit d’une classe scellée (NotInheritabledans Visual Basic), une vérification dans le formulaire obj is Point en C# ou TryCast(obj, Point) dans Visual Basic est suffisante pour s’assurer qu’il obj s’agit d’un Point3D objet. S’il s’agit d’un Point3D objet, il est converti en Point objet et passé à 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 est généralement accompli 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 Example
   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 de valeur, il ne peut pas être dérivé. Par conséquent, le remplacement de 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 plutôt utiliser l’opérateur is en C# ou l’opérateur TypeOf dans Visual Basic pour vérifier le type du obj paramètre.

Remarques

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 référence, la Equals(Object) méthode teste l’égalité 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 référence, et appelle le Person constructeur de classe pour instancier deux nouveaux Person objets, person1a et person2, qui ont la même valeur. Il affecte person1a également à une autre variable d’objet. person1b Comme le montre la sortie de l’exemple et person1a person1b sont égales, 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 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
    
    // 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 Person
       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 Example
       Public Sub Main()
          Dim person1a As New Person("John")
          Dim person1b As Person = person1a
          Dim person2 As 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()
          
          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 égal à 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 Example
         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 person2qui ont la même valeur. Comme le montre la sortie de l’exemple, bien que les deux variables d’objet font référence à des objets différents et person2 soient égales, person1 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 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
      
      // 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 Person
         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 Example
         Public Sub Main()
            Dim p1 As New Person("John")
            Dim p2 As New Person("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 du .NET Framework, 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ériteurs.

Remarques relatives au Windows Runtime

Lorsque vous appelez la surcharge de Equals(Object) méthode sur une classe dans le Windows Runtime, elle fournit le comportement par défaut pour les classes qui ne remplacent Equals(Object)pas . Cela fait partie du support fourni par le .NET Framework pour le Windows Runtime (voir .NET Framework Support pour les applications Windows Store et Windows Runtime). Les classes de l’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 des méthodes lorsque vous les utilisez dans votre code C# ou Visual Basic, et le .NET Framework fournit le comportement par défaut pour ces méthodes.

Notes

Windows Runtime classes écrites en C# ou Visual Basic peuvent remplacer la surcharge de méthodeEquals(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 souvent 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 aux Equals méthodes. Le premier appel de méthode retourne true, et les trois autres retours false.

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
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 Example
   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 un Object, 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 s’agit StringBuilder d’un type référence, cela équivaut à passer 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ériteurs

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 le .NET Framework.

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égué MulticastDelegate.Equals Les délégués doivent avoir le même type avec des listes d’appel identiques.
Interface Object.Equals(Object) Égalité de référence.

Pour un type valeur, vous devez toujours remplacer Equals, car les tests d’égalité qui reposent sur la réflexion offrent des performances médiocres. Vous pouvez également remplacer l’implémentation par défaut des Equals types référence pour tester l’égalité des valeurs au lieu de l’égalité de référence 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 à 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. Elle remplace la Equals méthode de la Person classe. Si Person elle accepte son implémentation de classe de base d’égalité, deux Person objets sont égaux uniquement 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 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
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 Example
   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 Equalsla substitution, 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, et y``z représenter des 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 .

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

  • x.Equals(null) retourne false.

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

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

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

  • Les types qui remplacent doivent également remplacer Equals(Object) 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 IEquatable<T>.Equals implémentation 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 s’assurer 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 de 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 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 de 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 substitution Equals 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 de valeurs

Les instructions suivantes s’appliquent à la Equals(Object) substitution d’un type de valeur :

  • Si vous définissez un type de 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 une comparaison d’octets par octets pour les types de valeurs dont les champs sont tous les types de valeur, mais utilise la réflexion pour effectuer une comparaison de champs par champ de types de valeurs dont les champs incluent des types de 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 .

Voir aussi

S’applique à

Equals(Object, Object)

Détermine si les instances d'objet spécifiées sont considérées comme égales.

public:
 static bool Equals(System::Object ^ objA, System::Object ^ objB);
public static bool Equals (object objA, object objB);
public static bool Equals (object? objA, object? objB);
static member Equals : obj * obj -> bool
Public Shared Function Equals (objA As Object, objB As Object) As Boolean

Paramètres

objA
Object

Premier objet à comparer.

objB
Object

Deuxième objet à comparer.

Retours

Boolean

true si les objets sont considérés comme identiques ; sinon, false. Si objA et objB ont tous deux la valeur null, la méthode retourne true.

Exemples

L’exemple suivant illustre la Equals(Object, Object) méthode et la compare à la ReferenceEquals méthode.

using System;

public class Example
{
   public static void Main()
   {
      Dog m1 = new Dog("Alaskan Malamute");
      Dog m2 = new Dog("Alaskan Malamute");
      Dog g1 = new Dog("Great Pyrenees");
      Dog g2 = g1;
      Dog d1 = new Dog("Dalmation");
      Dog n1 = null;
      Dog n2 = null;

      Console.WriteLine("null = null: {0}", Object.Equals(n1, n2));
      Console.WriteLine("null Reference Equals null: {0}\n", Object.ReferenceEquals(n1, n2));

      Console.WriteLine("{0} = {1}: {2}", g1, g2, Object.Equals(g1, g2));
      Console.WriteLine("{0} Reference Equals {1}: {2}\n", g1, g2, Object.ReferenceEquals(g1, g2));

      Console.WriteLine("{0} = {1}: {2}", m1, m2, Object.Equals(m1, m2));
      Console.WriteLine("{0} Reference Equals {1}: {2}\n", m1, m2, Object.ReferenceEquals(m1, m2));

      Console.WriteLine("{0} = {1}: {2}", m1, d1, Object.Equals(m1, d1));
      Console.WriteLine("{0} Reference Equals {1}: {2}", m1, d1, Object.ReferenceEquals(m1, d1));
   }
}

public class Dog
{
   // Public field.
   public string Breed;

   // Class constructor.
   public Dog(string dogBreed)
   {
      this.Breed = dogBreed;
   }

   public override bool Equals(Object obj)
   {
      if (obj == null || !(obj is Dog))
         return false;
      else
         return this.Breed == ((Dog) obj).Breed;
   }

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

   public override string ToString()
   {
      return this.Breed;
   }
}
// The example displays the following output:
//       null = null: True
//       null Reference Equals null: True
//
//       Great Pyrenees = Great Pyrenees: True
//       Great Pyrenees Reference Equals Great Pyrenees: True
//
//       Alaskan Malamute = Alaskan Malamute: True
//       Alaskan Malamute Reference Equals Alaskan Malamute: False
//
//       Alaskan Malamute = Dalmation: False
//       Alaskan Malamute Reference Equals Dalmation: False
open System

// Class constructor
type Dog(dogBreed) =
    // Public property.
    member _.Breed = dogBreed

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

    override _.GetHashCode() =
        dogBreed.GetHashCode()

    override _.ToString() =
        dogBreed

let m1 = Dog "Alaskan Malamute"
let m2 = Dog "Alaskan Malamute"
let g1 = Dog "Great Pyrenees"
let g2 = g1
let d1 = Dog "Dalmation"
let n1 = Unchecked.defaultof<Dog>
let n2 = Unchecked.defaultof<Dog>

printfn $"null = null: {Object.Equals(n1, n2)}"
printfn $"null Reference Equals null: {Object.ReferenceEquals(n1, n2)}\n"

printfn $"{g1} = {g2}: {Object.Equals(g1, g2)}"
printfn $"{g1} Reference Equals {g2}: {Object.ReferenceEquals(g1, g2)}\n"

printfn $"{m1} = {m2}: {Object.Equals(m1, m2)}"
printfn $"{m1} Reference Equals {m2}: {Object.ReferenceEquals(m1, m2)}\n"

printfn $"{m1} = {d1}: {Object.Equals(m1, d1)}"
printfn $"{m1} Reference Equals {d1}: {Object.ReferenceEquals(m1, d1)}"

// The example displays the following output:
//       null = null: True
//       null Reference Equals null: True
//
//       Great Pyrenees = Great Pyrenees: True
//       Great Pyrenees Reference Equals Great Pyrenees: True
//
//       Alaskan Malamute = Alaskan Malamute: True
//       Alaskan Malamute Reference Equals Alaskan Malamute: False
//
//       Alaskan Malamute = Dalmation: False
//       Alaskan Malamute Reference Equals Dalmation: False
Module Example
   Public Sub Main()
      Dim m1 As New Dog("Alaskan Malamute")
      Dim m2 As New Dog("Alaskan Malamute")
      Dim g1 As New Dog("Great Pyrenees")
      Dim g2 As Dog = g1
      Dim d1 As New Dog("Dalmation")
      Dim n1 As Dog = Nothing
      Dim n2 As Dog = Nothing
      
      Console.WriteLine("null = null: {0}", Object.Equals(n1, n2))
      Console.WriteLine("null Reference Equals null: {0}", Object.ReferenceEquals(n1, n2))
      Console.WriteLine()
      
      Console.WriteLine("{0} = {1}: {2}", g1, g2, Object.Equals(g1, g2))
      Console.WriteLine("{0} Reference Equals {1}: {2}", g1, g2, Object.ReferenceEquals(g1, g2))
      Console.WriteLine()
      
      Console.WriteLine("{0} = {1}: {2}", m1, m2, Object.Equals(m1, m2))
      Console.WriteLine("{0} Reference Equals {1}: {2}", m1, m2, Object.ReferenceEquals(m1, m2))
      Console.WriteLine()
      
      Console.WriteLine("{0} = {1}: {2}", m1, d1, Object.Equals(m1, d1))  
      Console.WriteLine("{0} Reference Equals {1}: {2}", m1, d1, Object.ReferenceEquals(m1, d1))  
   End Sub
End Module

Public Class Dog
   ' Public field.
   Public Breed As String
   
   ' Class constructor.
   Public Sub New(dogBreed As String)
      Me.Breed = dogBreed
   End Sub

   Public Overrides Function Equals(obj As Object) As Boolean
      If obj Is Nothing OrElse Not typeof obj Is Dog Then
         Return False
      Else
         Return Me.Breed = CType(obj, Dog).Breed
      End If   
   End Function
   
   Public Overrides Function GetHashCode() As Integer
      Return Me.Breed.GetHashCode()
   End Function
   
   Public Overrides Function ToString() As String
      Return Me.Breed
   End Function
End Class
' The example displays the following output:
'       null = null: True
'       null Reference Equals null: True
'       
'       Great Pyrenees = Great Pyrenees: True
'       Great Pyrenees Reference Equals Great Pyrenees: True
'       
'       Alaskan Malamute = Alaskan Malamute: True
'       Alaskan Malamute Reference Equals Alaskan Malamute: False
'       
'       Alaskan Malamute = Dalmation: False
'       Alaskan Malamute Reference Equals Dalmation: False

Remarques

La méthode statique Equals(Object, Object) indique si deux objets objA et objB, sont égaux. Il vous permet également de tester des objets dont la valeur est null pour l’égalité. Il compare objA et objB pour l’égalité comme suit :

  • Il détermine si les deux objets représentent la même référence d’objet. S’ils le font, la méthode retourne true. Ce test équivaut à appeler la ReferenceEquals méthode. En outre, si les deux objA et objB sont null, la méthode retourne true.

  • Il détermine s’il objA s’agit d’une valeur null ou objB non. Si c’est le cas, elle retourne false.

  • Si les deux objets ne représentent pas la même référence d’objet et qu’aucun n’est null, il appelle objA.Equals (objB) et retourne le résultat. Cela signifie que si objA elle remplace la Object.Equals(Object) méthode, cette substitution est appelée.

Voir aussi

S’applique à