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

Parameter

Gibt zurück

true wenn das aktuelle Objekt dem other Parameter entspricht; andernfalls false.

Beispiele

Das folgende Beispiel zeigt die partielle Implementierung einer Person Klasse, die zwei Eigenschaften implementiert IEquatable<T> und verfügt. LastNameNationalId NationalIdwird als eindeutiger Bezeichner betrachtet, daher gibt die Methode zurückEquals, wenn die True Eigenschaft von zwei NationalId Objekten identisch ist; andernfalls wird sie zurückgegebenPerson.False (Beachten Sie, dass im F#-Beispiel keine Werte für null Instanzen behandelt Person werden.)

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

Wenn eine Person Datei in einer List<T>gespeichert wird, wird die Contains Implementierung verwendet, Equals um nach einer Übereinstimmung zu suchen.

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

Hinweise

Die Implementierung der Equals Methode soll einen Test für die Gleichheit mit einem anderen Objekt vom Typ T, demselben Typ wie das aktuelle Objekt, durchführen. Die Equals(T) Methode wird unter folgenden Umständen aufgerufen:

• Wenn die Equals Methode aufgerufen wird und das other Argument ein stark typiertes Objekt vom Typ Tist. (Wenn other nicht vom Typ ist T, wird die Basismethode Object.Equals(Object) aufgerufen. Von den beiden Methoden bietet IEquatable<T>.Equals etwas bessere Leistung.)

• Wenn die Suchmethoden einer Reihe generischer Auflistungsobjekte aufgerufen werden. Einige dieser Typen und deren Methoden umfassen Folgendes:

  • Einige der generischen Überladungen der BinarySearch Methode.

  • Die Suchmethoden der List<T> Klasse, einschließlich List<T>.Contains(T), List<T>.IndexOf, List<T>.LastIndexOf, und List<T>.Remove.

  • Die Suchmethoden der Dictionary<TKey,TValue> Klasse, einschließlich ContainsKey und Remove.

  • Die Suchmethoden der generischen LinkedList<T> Klasse, einschließlich LinkedList<T>.Contains und Remove.

Anders ausgedrückt: Um die Möglichkeit zu behandeln, dass Objekte einer Klasse in einem Array oder einem generischen Auflistungsobjekt gespeichert werden, empfiehlt es sich, das Objekt so zu implementieren IEquatable<T> , dass das Objekt leicht identifiziert und bearbeitet werden kann.

Definieren Sie bei der Implementierung der Equals Methode die Gleichheit entsprechend für den vom generischen Typargument angegebenen Typ. Wenn das Typargument beispielsweise lautet Int32, definieren Sie die Gleichheit entsprechend für den Vergleich von zwei 32-Bit-Ganzzahlen mit Vorzeichen.

Hinweise für Ausführende

Wenn Sie die Implementierung implementieren, sollten Sie auch die Implementierungen Equals(T) der Basisklassen außer Kraft setzen Equals(Object)und GetHashCode() damit ihr Verhalten mit der Equals(T) der Methode konsistent ist. Wenn Sie außer Kraft setzen Equals(Object), wird ihre außerKraftsetzungsimplementierung auch in Aufrufen der statischen Equals(System.Object, System.Object) Methode für Ihre Klasse aufgerufen. Darüber hinaus sollten Sie die op_Equality Operatoren überladen op_Inequality . Dadurch wird sichergestellt, dass alle Tests auf Gleichheit konsistente Ergebnisse zurückgeben, die das Beispiel veranschaulicht.