IEquatable<T>.Equals(T) Methode

public:
 bool Equals(T other);

public bool Equals(T other);

public bool Equals(T? other);

abstract member Equals : 'T -> bool

Public Function Equals (other As T) As Boolean

Parameters

Retouren

trueals het huidige object gelijk is aan de other parameter; anders. false

Voorbeelden

In het volgende voorbeeld ziet u de gedeeltelijke implementatie van een Person klasse die twee eigenschappen implementeert IEquatable<T> en heeft, LastName en NationalId. NationalIdwordt beschouwd als een unieke id, daarom retourneert de Equals methode als de True eigenschap van twee NationalId objecten identiek is; anders wordt deze geretourneerdPersonFalse. (In het F#-voorbeeld worden geen waarden voor null exemplaren verwerktPerson.)

public class Person : IEquatable<Person>
{
    public Person(string lastName, string ssn)
    {
        LastName = lastName;
        NationalId = ssn;
    }

    public string LastName { get; }

    public string NationalId { get; }

    public bool Equals(Person? other) => other is not null && other.NationalId == NationalId;

    public override bool Equals(object? obj) => Equals(obj as Person);

    public override int GetHashCode() => NationalId.GetHashCode();

    public static bool operator ==(Person person1, Person person2)
    {
        if (person1 is null)
        {
            return person2 is null;
        }

        return person1.Equals(person2);
    }

    public static bool operator !=(Person person1, Person person2)
    {
        if (person1 is null)
        {
            return person2 is not null;
        }

        return !person1.Equals(person2);
    }
}

open System

type Person(lastName: string, nationalId: string) =
    member this.LastName = lastName
    member this.NationalId = nationalId

    interface IEquatable<Person> with
        member this.Equals(other: Person) =
            other.NationalId = this.NationalId

    override this.Equals(obj: obj) =
        match obj with
        | :? Person as person -> (this :> IEquatable<Person>).Equals(person)
        | _ -> false

    override this.GetHashCode() =
        this.NationalId.GetHashCode()

    static member (==) (person1: Person, person2: Person) =
        person1.Equals(person2)

    static member (!=) (person1: Person, person2: Person) =
        not (person1.Equals(person2))

Public Class Person
    Implements IEquatable(Of Person)

    Public Sub New(lastName As String, nationalId As String)
        Me.LastName = lastName
        Me.NationalId = nationalId
    End Sub

    Public ReadOnly Property LastName As String
    Public ReadOnly Property NationalId As String

    Public Overloads Function Equals(other As Person) As Boolean Implements IEquatable(Of Person).Equals
        Return other IsNot Nothing AndAlso other.NationalId = Me.NationalId
    End Function

    Public Overrides Function Equals(obj As Object) As Boolean
        Return Equals(TryCast(obj, Person))
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return NationalId.GetHashCode()
    End Function

    Public Shared Operator =(person1 As Person, person2 As Person) As Boolean
        If person1 Is Nothing Then
            Return person2 Is Nothing
        End If
        Return person1.Equals(person2)
    End Operator

    Public Shared Operator <>(person1 As Person, person2 As Person) As Boolean
        If person1 Is Nothing Then
            Return person2 IsNot Nothing
        End If
        Return Not person1.Equals(person2)
    End Operator
End Class

Wanneer een Person bestand wordt opgeslagen in een List<T>, Contains wordt de Equals implementatie gebruikt om te zoeken naar een overeenkomst.

List<Person> applicants = new List<Person>()
{
    new Person("Jones", "099-29-4999"),
    new Person("Jones", "199-29-3999"),
    new Person("Jones", "299-49-6999")
};

// Create a Person object for the final candidate.
Person candidate = new Person("Jones", "199-29-3999");
bool contains = applicants.Contains(candidate);
Console.WriteLine($"{candidate.LastName} ({candidate.NationalId}) is on record: {contains}");
// The example prints the following output:
// Jones (199-29-3999) is on record: True

let applicants = 
    [ Person("Jones", "099-29-4999")
      Person("Jones", "199-29-3999")
      Person("Jones", "299-49-6999") ]

let candidate = Person("Jones", "199-29-3999")
let contains = List.contains candidate applicants
printfn "%s (%s) is on record: %b" candidate.LastName candidate.NationalId contains
// The example prints the following output:
// Jones (199-29-3999) is on record: true

Dim applicants As New List(Of Person)
applicants.Add(New Person("Jones", "099-29-4999"))
applicants.Add(New Person("Jones", "199-29-3999"))
applicants.Add(New Person("Jones", "299-49-6999"))

' Create a Person object for the final candidate.
Dim candidate As New Person("Jones", "199-29-3999")
Dim contains As Boolean = applicants.Contains(candidate)
Console.WriteLine($"{candidate.LastName} ({candidate.NationalId}) is on record: {contains}")
' The example prints the following output:
' Jones (199-29-3999) Is on record True

Opmerkingen

De implementatie van de Equals methode is bedoeld om een test uit te voeren op gelijkheid met een ander object van het type T, hetzelfde type als het huidige object. De Equals(T) methode wordt aangeroepen in de volgende omstandigheden:

• Wanneer de Equals methode wordt aangeroepen en het other argument een sterk getypt object van het type Tis. (Als other dit niet van het type Tis, wordt de basismethode Object.Equals(Object) aangeroepen. Van de twee methoden biedt IEquatable<T>.Equals iets betere prestaties.)

• Wanneer de zoekmethoden van een aantal algemene verzamelingsobjecten worden aangeroepen. Enkele van deze typen en hun methoden zijn onder andere:

  • Sommige algemene overbelastingen van de BinarySearch methode.

  • De zoekmethoden van de List<T> klasse, waaronder List<T>.Contains(T), List<T>.IndexOf, List<T>.LastIndexOfen List<T>.Remove.

  • De zoekmethoden van de Dictionary<TKey,TValue> klasse, inclusief ContainsKey en Remove.

  • De zoekmethoden van de algemene LinkedList<T> klasse, inclusief LinkedList<T>.Contains en Remove.

Met andere woorden, om de mogelijkheid te verwerken dat objecten van een klasse worden opgeslagen in een matrix of een algemeen verzamelingsobject, is het een goed idee om het object te implementeren IEquatable<T> , zodat het object eenvoudig kan worden geïdentificeerd en gemanipuleerd.

Bij het implementeren van de Equals methode definieert u gelijkheid op de juiste wijze voor het type dat is opgegeven door het algemene typeargument. Als het typeargument bijvoorbeeld is Int32, definieert u gelijkheid voor de vergelijking van twee 32-bits ondertekende gehele getallen.

Notities voor uitvoerders

Als u implementeert Equals(T), moet u ook de basisklasse-implementaties Equals(Object)GetHashCode() van en zodanig overschrijven dat hun gedrag consistent is met die van de Equals(T) methode. Als u de Equals(Object)onderdrukking uitvoert, wordt uw overschreven implementatie ook aangeroepen in aanroepen naar de statische Equals(System.Object, System.Object) methode in uw klas. Bovendien moet u de op_Equality en op_Inequality operators overbelasten. Dit zorgt ervoor dat alle tests voor gelijkheid consistente resultaten retourneren, die in het voorbeeld worden geïllustreerd.