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

true, wenn das aktuelle Objekt gleich dem other-Parameter ist, andernfalls false.

Das folgende Beispiel zeigt die partielle Implementierung einer Person Klasse, die implementiert IEquatable<T> und über zwei Eigenschaften verfügt, LastName und SSN. Die Equals -Methode gibt zurück True , wenn die SSN -Eigenschaft von zwei Person -Objekten identisch ist, andernfalls wird zurückgegeben False.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Person : IEquatable<Person>
{
   private string uniqueSsn;
   private string lName;

   public Person(string lastName, string ssn)
   {
      if (Regex.IsMatch(ssn, @"\d{9}"))
        uniqueSsn = $"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}";
      else if (Regex.IsMatch(ssn, @"\d{3}-\d{2}-\d{4}"))
         uniqueSsn = ssn;
      else
         throw new FormatException("The social security number has an invalid format.");

      this.LastName = lastName;
   }

   public string SSN
   {
      get { return this.uniqueSsn; }
   }

   public string LastName
   {
      get { return this.lName; }
      set {
         if (String.IsNullOrEmpty(value))
            throw new ArgumentException("The last name cannot be null or empty.");
         else
            this.lName = value;
      }
   }

   public bool Equals(Person other)
   {
      if (other == null)
         return false;

      if (this.uniqueSsn == other.uniqueSsn)
         return true;
      else
         return false;
   }

   public override bool Equals(Object obj)
   {
      if (obj == null)
         return false;

      Person personObj = obj as Person;
      if (personObj == null)
         return false;
      else
         return Equals(personObj);
   }

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

   public static bool operator == (Person person1, Person person2)
   {
      if (((object)person1) == null || ((object)person2) == null)
         return Object.Equals(person1, person2);

      return person1.Equals(person2);
   }

   public static bool operator != (Person person1, Person person2)
   {
      if (((object)person1) == null || ((object)person2) == null)
         return ! Object.Equals(person1, person2);

      return ! (person1.Equals(person2));
   }
}

open System
open System.Text.RegularExpressions

type Person(lastName, ssn) =
    let mutable lastName = lastName
    let ssn = 
        if Regex.IsMatch(ssn, @"\d{9}") then
            $"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}"
        elif Regex.IsMatch(ssn, @"\d{3}-\d{2}-\d{4}") then
            ssn
        else
            raise (FormatException "The social security number has an invalid format.")

    member _.SSN =
        ssn

    member _.LastName
        with get () = lastName
        and set (value) =
            if String.IsNullOrEmpty value then
                invalidArg (nameof value) "The last name cannot be null or empty."
            else
                lastName <- value

    static member op_Equality (person1: Person, person2: Person) =
        if box person1 |> isNull || box person2 |> isNull then
            Object.Equals(person1, person2)
        else
            person1.Equals person2

    static member op_Inequality (person1: Person, person2: Person) =
        if box person1 |> isNull || box person2 |> isNull then
            Object.Equals(person1, person2) |> not
        else
            person1.Equals person2 |> not

    override _.GetHashCode() =
        ssn.GetHashCode()

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

    interface IEquatable<Person> with
        member this.Equals(other: Person) =
            match box other with 
            | null -> false
            | _ ->
                this.SSN = other.SSN

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Public Class Person : Implements IEquatable(Of Person)
   Private uniqueSsn As String
   Private lName As String
   
   Public Sub New(lastName As String, ssn As String)
      If Regex.IsMatch(ssn, "\d{9}") Then
         uniqueSsn = $"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}"
      ElseIf Regex.IsMatch(ssn, "\d{3}-\d{2}-\d{4}") Then
         uniqueSsn = ssn
      Else 
         Throw New FormatException("The social security number has an invalid format.")
      End If
      Me.LastName = lastName
   End Sub
   
   Public ReadOnly Property SSN As String
      Get
         Return Me.uniqueSsn
      End Get      
   End Property
   
   Public Property LastName As String
      Get
         Return Me.lName
      End Get
      Set
         If String.IsNullOrEmpty(value) Then
            Throw New ArgumentException("The last name cannot be null or empty.")
         Else
            lname = value
         End If   
      End Set
   End Property
   
   Public Overloads Function Equals(other As Person) As Boolean _
                   Implements IEquatable(Of Person).Equals
      If other Is Nothing Then Return False
      
      If Me.uniqueSsn = other.uniqueSsn Then
         Return True
      Else
         Return False
      End If
   End Function

   Public Overrides Function Equals(obj As Object) As Boolean
      If obj Is Nothing Then Return False
      
      Dim personObj As Person = TryCast(obj, Person)
      If personObj Is Nothing Then
         Return False
      Else   
         Return Equals(personObj)   
      End If
   End Function   
   
   Public Overrides Function GetHashCode() As Integer
      Return Me.SSN.GetHashCode()
   End Function
   
   Public Shared Operator = (person1 As Person, person2 As Person) As Boolean
      If person1 Is Nothing OrElse person2 Is Nothing Then
         Return Object.Equals(person1, person2)
      End If
         
      Return person1.Equals(person2)
   End Operator
   
   Public Shared Operator <> (person1 As Person, person2 As Person) As Boolean
      If person1 Is Nothing OrElse person2 Is Nothing Then
         Return Not Object.Equals(person1, person2) 
      End If
      
      Return Not person1.Equals(person2)
   End Operator
End Class

Person -Objekte können dann in einem List<T> -Objekt gespeichert und durch die Contains -Methode identifiziert werden, wie im folgenden Beispiel gezeigt.

public class TestIEquatable
{
   public static void Main()
   {
      // Create a Person object for each job applicant.
      Person applicant1 = new Person("Jones", "099-29-4999");
      Person applicant2 = new Person("Jones", "199-29-3999");
      Person applicant3 = new Person("Jones", "299-49-6999");

      // Add applicants to a List object.
      List<Person> applicants = new List<Person>();
      applicants.Add(applicant1);
      applicants.Add(applicant2);
      applicants.Add(applicant3);

       // Create a Person object for the final candidate.
       Person candidate = new Person("Jones", "199-29-3999");
       if (applicants.Contains(candidate))
          Console.WriteLine("Found {0} (SSN {1}).",
                             candidate.LastName, candidate.SSN);
      else
         Console.WriteLine("Applicant {0} not found.", candidate.SSN);

      // Call the shared inherited Equals(Object, Object) method.
      // It will in turn call the IEquatable(Of T).Equals implementation.
      Console.WriteLine("{0}({1}) already on file: {2}.",
                        applicant2.LastName,
                        applicant2.SSN,
                        Person.Equals(applicant2, candidate));
   }
}
// The example displays the following output:
//       Found Jones (SSN 199-29-3999).
//       Jones(199-29-3999) already on file: True.

// Create a Person object for each job applicant.
let applicant1 = Person("Jones", "099-29-4999")
let applicant2 = Person("Jones", "199-29-3999")
let applicant3 = Person("Jones", "299-49-6999")

// Add applicants to a List object.
let applicants = ResizeArray()
applicants.Add applicant1
applicants.Add applicant2
applicants.Add applicant3

// Create a Person object for the final candidate.
let candidate = Person("Jones", "199-29-3999")
if applicants.Contains candidate then
    printfn $"Found {candidate.LastName} (SSN {candidate.SSN})."
else
    printfn $"Applicant {candidate.SSN} not found."

// Call the shared inherited Equals(Object, Object) method.
// It will in turn call the IEquatable<T>.Equals implementation.
printfn $"{applicant2.LastName}({applicant2.SSN}) already on file: {Person.Equals(applicant2, candidate)}."

// The example displays the following output:
//       Found Jones (SSN 199-29-3999).
//       Jones(199-29-3999) already on file: True.

Module TestIEquatable
   Public Sub Main()
      ' Create a Person object for each job applicant.
      Dim applicant1 As New Person("Jones", "099-29-4999")
      Dim applicant2 As New Person("Jones", "199-29-3999")
      Dim applicant3 As New Person("Jones", "299-49-6999")

      ' Add applicants to a List object.
      Dim applicants As New List(Of Person)
      applicants.Add(applicant1)
      applicants.Add(applicant2)
      applicants.Add(applicant3)
      
      ' Create a Person object for the final candidate.
      Dim candidate As New Person("Jones", "199-29-3999")
      
      If applicants.Contains(candidate) Then
         Console.WriteLine("Found {0} (SSN {1}).", _
                            candidate.LastName, candidate.SSN)
      Else
         Console.WriteLine("Applicant {0} not found.", candidate.SSN)
      End If         

      ' Call the shared inherited Equals(Object, Object) method.
      ' It will in turn call the IEquatable(Of T).Equals implementation.
      Console.WriteLine("{0}({1}) already on file: {2}.", _ 
                        applicant2.LastName, _
                        applicant2.SSN, _
                        Person.Equals(applicant2, candidate)) 
   End Sub
End Module
' The example displays the following output:
'       Found Jones (SSN 199-29-3999).
'       Jones(199-29-3999) already on file: True.

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

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

• Wenn die Suchmethoden einer Reihe generischer Auflistungsobjekte aufgerufen werden. Einige dieser Typen und ihre 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>.LastIndexOfund 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, zu implementieren IEquatable<T> , damit das Objekt leicht identifiziert und bearbeitet werden kann.

Wenn Sie die Equals -Methode implementieren, definieren Sie die Gleichheit entsprechend für den Typ, der durch das generische Typargument angegeben wird. Wenn das Typargument beispielsweise lautet Int32, definieren Sie die Gleichheit entsprechend für den Vergleich von zwei 32-Bit-Ganzzahlen mit Vorzeichen.

Wenn Sie implementieren Equals(T), sollten Sie auch die Basisklassenimplementierungen von Equals(Object) und GetHashCode() überschreiben, damit ihr Verhalten mit dem Equals(T) der -Methode konsistent ist. Wenn Sie überschreiben Equals(Object), wird Ihre überschriebene Implementierung 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 und op_Inequality überladen. Dadurch wird sichergestellt, dass alle Gleichheitstests konsistente Ergebnisse zurückgeben, was im Beispiel veranschaulicht wird.