Methode System.Object.Equals

Notitie

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

Dit artikel heeft betrekking op de methode Object.Equals(Object).

Het type vergelijking tussen het huidige exemplaar en de parameter obj is afhankelijk van of het huidige exemplaar een verwijzingstype of een waardetype is.

Als het huidige exemplaar een verwijzingstype is, test de Equals(Object) methode op gelijkheid van verwijzingen en is een aanroep van de methode Equals(Object) gelijk aan een aanroep van de ReferenceEquals methode. Verwijzings gelijkheid betekent dat de objectvariabelen die worden vergeleken verwijzen naar hetzelfde object. In het volgende voorbeeld ziet u het resultaat van een dergelijke vergelijking. Het definieert een Person-klasse, een verwijzingstype, en roept de Person klasseconstructor aan om twee nieuwe Person-objecten te instantiëren, person1a en person2, die dezelfde waarde hebben. Het wijst ook person1a toe aan een andere objectvariabele, person1b. Zoals de uitvoer uit het voorbeeld laat zien, zijn person1a en person1b gelijk omdat ze verwijzen naar hetzelfde object. person1a en person2 zijn echter niet gelijk, hoewel ze dezelfde waarde hebben.

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

Als het huidige exemplaar een waardetype is, wordt met de Equals(Object) methode getest op gelijkheid van waarden. Gelijkheid van waarden betekent het volgende:

De twee objecten zijn van hetzelfde type. Zoals in het volgende voorbeeld wordt weergegeven, is een Byte object met een waarde van 12 niet gelijk aan een Int32 object met een waarde van 12, omdat de twee objecten verschillende runtimetypen hebben.

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

De waarden van de openbare en persoonlijke velden van de twee objecten zijn gelijk. In het volgende voorbeeld wordt getest op gelijkheid van waarden. Het definieert een Person structuur, een waardetype, en roept de Person klasseconstructor aan om twee nieuwe Person-objecten te instantiëren, person1 en person2, die dezelfde waarde hebben. Zoals in de uitvoer van het voorbeeld wordt weergegeven, hoewel de twee objectvariabelen naar verschillende objecten verwijzen, zijn person1 en person2 gelijk omdat ze dezelfde waarde hebben voor het privé-personName veld.

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

Omdat de Object klasse de basisklasse is voor alle typen in .NET, biedt de Object.Equals(Object) methode de standaard gelijkheidsvergelijking voor alle andere typen. Typen overschrijven echter vaak de Equals methode om gelijkheid van waarden te implementeren. Zie de secties Notities voor bellers en notities voor overnames voor meer informatie.

Notities voor Windows Runtime

Wanneer u de overload van de Equals(Object)-methode op een klasse in Windows Runtime aanroept, biedt deze het standaardgedrag voor klassen die Equals(Object)niet overschrijven. Dit maakt deel uit van de ondersteuning die .NET biedt voor De Windows Runtime (zie .NET-ondersteuning voor Windows Store-apps en Windows Runtime). Klassen in Windows Runtime nemen geen Objectover en implementeren momenteel geen Equals(Object) methode. Ze lijken echter ToString, Equals(Object)en GetHashCode methoden te hebben wanneer u deze gebruikt in uw C#- of Visual Basic-code, en .NET biedt het standaardgedrag voor deze methoden.

Notitie

Windows Runtime-klassen die zijn geschreven in C# of Visual Basic, kunnen de overbelasting van de Equals(Object) methode overschrijven.

Notities voor bellers

Afgeleide klassen overschrijven vaak de Object.Equals(Object) methode om gelijkheid van waarden te implementeren. Bovendien bieden typen vaak ook een extra sterk getypte overbelasting aan de Equals methode, meestal door de IEquatable<T> interface te implementeren. Wanneer u de methode Equals aanroept om te testen op gelijkheid, moet u weten of het huidige exemplaar Object.Equals overschrijft en begrijpt hoe een bepaalde aanroep van een Equals-methode wordt opgelost. Anders voert u mogelijk een test uit op gelijkheid die verschilt van wat u bedoelde en de methode kan een onverwachte waarde retourneren.

In het volgende voorbeeld ziet u een afbeelding. Er worden drie StringBuilder objecten met identieke tekenreeksen geïnstitueert en er worden vervolgens vier aanroepen naar Equals methoden gemaakt. De eerste methode-aanroep retourneert trueen de resterende drie 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

In het eerste geval wordt de sterk getypte StringBuilder.Equals(StringBuilder) methode overload, die test op waarde gelijkheid, aangeroepen. Omdat de tekenreeksen die zijn toegewezen aan de twee StringBuilder objecten gelijk zijn, retourneert de methode true. StringBuilder overschrijft echter Object.Equals(Object)niet. Als het StringBuilder object daarom wordt omgezet in een Object, wanneer een StringBuilder exemplaar wordt toegewezen aan een variabele van het type Objecten wanneer de Object.Equals(Object, Object) methode wordt doorgegeven aan twee StringBuilder objecten, wordt de standaardmethode Object.Equals(Object) aangeroepen. Omdat StringBuilder een verwijzingstype is, is dit gelijk aan het doorgeven van de twee StringBuilder objecten aan de ReferenceEquals methode. Hoewel alle drie StringBuilder objecten identieke tekenreeksen bevatten, verwijzen ze naar drie afzonderlijke objecten. Als gevolg hiervan retourneren deze drie methode-aanroepen false.

U kunt het huidige object vergelijken met een ander object om te verwijzen naar gelijkheid door de methode ReferenceEquals aan te roepen. In Visual Basic kunt u ook het is trefwoord (bijvoorbeeld If Me Is otherObject Then ...) gebruiken.

Notities voor erfgenamen

Wanneer u uw eigen type definieert, neemt dat type de functionaliteit over die is gedefinieerd door de Equals methode van het basistype. De volgende tabel bevat de standaard implementatie van de Equals methode voor de belangrijkste categorieën typen in .NET.

Typecategorie	Gelijkheid gedefinieerd door	Opmerkingen
Klasse die rechtstreeks is afgeleid van Object	Object.Equals(Object)	Referentie-gelijkheid; gelijk aan het aanroepen van Object.ReferenceEquals.
Structuur	ValueType.Equals	Gelijkheid van waarde; directe byte-bytevergelijking of veld-per-veldvergelijking met behulp van weerspiegeling.
Opsomming	Enum.Equals	Waarden moeten hetzelfde opsommingstype en dezelfde onderliggende waarde hebben.
Gedelegeerde	MulticastDelegate.Equals	Gemachtigden moeten hetzelfde type hebben met identieke aanroeplijsten.
gebruikersinterface	Object.Equals(Object)	Verwijzing naar gelijkheid.

Voor een waardetype moet u altijd Equalsoverschrijven, omdat tests voor gelijkheid die afhankelijk zijn van weerspiegeling slechte prestaties bieden. U kunt ook de standaard implementatie van Equals voor referentietypen overschrijven om te testen op gelijkheid van waarden in plaats van verwijzings gelijkheid en om de precieze betekenis van waarde gelijkheid te definiëren. Dergelijke implementaties van Equals retourneren true als de twee objecten dezelfde waarde hebben, zelfs als ze niet hetzelfde exemplaar zijn. De implementeerfunctie van het type bepaalt wat de waarde van een object is, maar dit zijn meestal enkele of alle gegevens die zijn opgeslagen in de instantievariabelen van het object. De waarde van een String object is bijvoorbeeld gebaseerd op de tekens van de tekenreeks; de String.Equals(Object) methode overschrijft de Object.Equals(Object) methode om true te retourneren voor twee tekenreeksexemplaren die dezelfde tekens in dezelfde volgorde bevatten.

In het volgende voorbeeld ziet u hoe u de methode Object.Equals(Object) overschrijft om te testen op gelijkheid van waarden. Hiermee wordt de Equals-methode voor de Person-class overschreven. Als Person de basisklasse-implementatie van gelijkheid heeft geaccepteerd, zijn twee Person objecten alleen gelijk als ze naar één object verwijzen. In dit geval zijn twee Person objecten echter gelijk als ze dezelfde waarde hebben voor de eigenschap Person.Id.

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

Naast het overschrijven van Equalskunt u de IEquatable<T>-interface implementeren om een sterk getypeerde test voor gelijkheid te bieden.

De volgende instructies moeten waar zijn voor alle implementaties van de methode Equals(Object). In de lijst vertegenwoordigen x, yen z objectverwijzingen die niet null-zijn.

x.Equals(x) retourneert true.
x.Equals(y) retourneert dezelfde waarde als y.Equals(x).
x.Equals(y) retourneert true als zowel x als yNaNzijn.
Als (x.Equals(y) && y.Equals(z))truegeeft, dan geeft x.Equals(z)true.
Opeenvolgende aanroepen naar x.Equals(y) retourneren dezelfde waarde zolang de objecten waarnaar wordt verwezen door x en y niet worden gewijzigd.
x.Equals(null) retourneert false.

Implementaties van Equals mogen geen uitzonderingen genereren; ze moeten altijd een waarde retourneren. Als obj bijvoorbeeld is null, moet de methode Equalsfalse retourneren in plaats van een ArgumentNullExceptionte genereren.

Volg deze richtlijnen bij het overschrijven van Equals(Object):

Typen die IComparable implementeren, moeten Equals(Object)overschrijven.
Typen die Equals(Object) overschrijven, moeten ook GetHashCodeoverschrijven; anders werken hashtabellen mogelijk niet correct.
Je zou kunnen overwegen om de IEquatable<T>-interface te implementeren om sterk getypte tests op gelijkheid te ondersteunen. Uw IEquatable<T>.Equals implementatie moet resultaten retourneren die consistent zijn met Equals.
Als uw programmeertaal overbelasting van operatoren ondersteunt en u de gelijkheidsoperator voor een bepaald type overbelast, moet u ook de methode Equals(Object) overschrijven om hetzelfde resultaat te retourneren als de gelijkheidsoperator. Dit helpt ervoor te zorgen dat klassebibliotheekcode die gebruikmaakt van Equals (zoals ArrayList en Hashtable) zich gedraagt op een manier die consistent is met de manier waarop de gelijkheidsoperator wordt gebruikt door toepassingscode.

Richtlijnen voor referentietypen

De volgende richtlijnen zijn van toepassing op het overschrijven van Equals(Object) voor een referentietype:

Overweeg Equals te overschrijven als de semantiek van het type is gebaseerd op het feit dat het type een of meer waarden vertegenwoordigt.
De meeste verwijzingstypen mogen de gelijkheidsoperator niet overbelasten, zelfs niet als ze Equalsoverschrijven. Als u echter een verwijzingstype implementeert dat is bedoeld om waardesemantiek te hebben, zoals een complex getaltype, moet u de gelijkheidsoperator overschrijven.
U moet Equals niet overschrijven op een mutabel referentietype. Dit komt doordat het overschrijven van Equals vereist dat u ook de GetHashCode methode overschrijft, zoals beschreven in de vorige sectie. Dit betekent dat de hashcode van een exemplaar van een veranderlijk verwijzingstype kan veranderen tijdens de levensduur, waardoor het object verloren kan gaan in een hash-tabel.

Richtlijnen voor waardetypen

De volgende richtlijnen zijn van toepassing op het overschrijven van Equals(Object) voor een waardetype:

Als u een waardetype definieert dat een of meer velden bevat waarvan de waarden verwijzingstypen zijn, moet u Equals(Object)overschrijven. De Equals(Object) implementatie die door ValueType wordt geleverd, voert een byte-bytevergelijking uit voor waardetypen waarvan de velden alle waardetypen zijn, maar er wordt weerspiegeling gebruikt om een veld-op-veldvergelijking uit te voeren van waardetypen waarvan de velden verwijzingstypen bevatten.
Als u Equals overschrijft en uw ontwikkeltaal overbelasting van operatoren ondersteunt, moet u de gelijkheidsoperator overbelasten.
U moet de IEquatable<T>-interface implementeren. Als u de sterk getypte methode IEquatable<T>.Equals aanroept, vermijdt u het boksen van het argument obj.

Voorbeelden

In het volgende voorbeeld ziet u een Point klasse die de methode Equals overschrijft om waarde-gelijkheid te bieden en een Point3D klasse die is afgeleid van Point. Omdat PointObject.Equals(Object) overschrijft om te testen op gelijkheid van waarden, wordt de methode Object.Equals(Object) niet aangeroepen. Point3D.Equals roept echter Point.Equals aan omdat PointObject.Equals(Object) implementeert op een manier die gelijkheid van waarde biedt.

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 HashCode.Combine(x, 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 HashCode.Combine(base.GetHashCode(), 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() =
        System.HashCode.Combine(x, 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() =
        System.HashCode.Combine(base.GetHashCode(), 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 HashCode.Combine(x, 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 HashCode.Combine(MyBase.GetHashCode(), 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

De methode Point.Equals controleert of het argument obj niet null- is en verwijst naar een exemplaar van hetzelfde type als dit object. Als een van de controles mislukt, retourneert de methode false.

Met Point.Equals de methode wordt de GetType methode aangeroepen om te bepalen of de runtimetypen van de twee objecten identiek zijn. Als de methode een controle van het formulier obj is Point in C# of TryCast(obj, Point) in Visual Basic heeft gebruikt, wordt de controle geretourneerd true in gevallen waarin obj een exemplaar is van een afgeleide klasse van Point, ook al obj is het huidige exemplaar niet van hetzelfde runtimetype. Na verificatie dat beide objecten van hetzelfde type zijn, plaatst de methode obj naar type Point en retourneert het het resultaat van het vergelijken van de instantievelden van de twee objecten.

In Point3D.Equalswordt de overgenomen Point.Equals methode, die Object.Equals(Object)overschrijft, aangeroepen voordat iets anders wordt gedaan. Omdat Point3D een verzegelde klasse (NotInheritable in Visual Basic) is, is een controle in het formulier obj is Point in C# of TryCast(obj, Point) in Visual Basic voldoende om ervoor te zorgen dat obj een Point3D object is. Als het een Point3D object is, wordt het gecast naar een Point object en doorgegeven aan de basisklasse-implementatie van Equals. Alleen wanneer de overgenomen Point.Equals methode true retourneert, vergelijkt de methode de z instantievelden die zijn geïntroduceerd in de afgeleide klasse.

In het volgende voorbeeld wordt een Rectangle-klasse gedefinieerd waarmee intern een rechthoek wordt geïmplementeerd als twee Point objecten. De Rectangle klasse overschrijft ook Object.Equals(Object) om waarde gelijkheid te bieden.

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

Sommige talen, zoals C# en Visual Basic, ondersteunen het overladen van operatoren. Wanneer een type de gelijkheidsoperator overbelast, moet deze ook de Equals(Object) methode overschrijven om dezelfde functionaliteit te bieden. Dit wordt meestal bereikt door de methode Equals(Object) te schrijven in termen van de overbelaste gelijkheidsoperator, zoals in het volgende voorbeeld.

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

Omdat Complex een waardetype is, kan het niet worden afgeleid van. Daarom hoeft de overschrijving van de methode Equals(Object) niet GetType aan te roepen om het exacte runtimetype van elk object te bepalen, maar kan in plaats daarvan de operator is in C# of de operator TypeOf in Visual Basic worden gebruikt om het type van de parameter obj te controleren.

Feedback

Is deze pagina nuttig?

Last updated on 2025-03-30