IEquatable<T>.Equals(T) Metodo

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

Parametri

Valori restituiti

true se l'oggetto corrente è uguale al other parametro ; in caso contrario, false.

Esempio

Nell'esempio seguente viene illustrata l'implementazione parziale di una Person classe che implementa IEquatable<T> e ha due proprietà e LastNameNationalId. NationalId viene considerato un identificatore univoco, pertanto il Equals metodo restituisce True se la NationalId proprietà di due Person oggetti è identica; in caso contrario, restituisce False. Si noti che l'esempio F# non gestisce null i valori per Person le istanze.

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

Quando un oggetto Person viene archiviato in un List<T>oggetto , Contains usa l'implementazione Equals per cercare una corrispondenza.

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

Commenti

L'implementazione del Equals metodo è progettata per eseguire un test di uguaglianza con un altro oggetto di tipo T, lo stesso tipo dell'oggetto corrente. Il Equals(T) metodo viene chiamato nelle circostanze seguenti:

• Quando viene chiamato il Equals metodo e l'argomento other è un oggetto fortemente tipizzato di tipo T. Se other non è di tipo T, viene chiamato il metodo di base Object.Equals(Object) . Dei due metodi, IEquatable<T>.Equals offre prestazioni leggermente migliori.

• Quando vengono chiamati i metodi di ricerca di un numero di oggetti raccolta generici. Alcuni di questi tipi e i relativi metodi includono:

  • Alcuni degli overload generici del BinarySearch metodo .

  • Metodi di ricerca della List<T> classe , inclusi List<T>.Contains(T), List<T>.IndexOfList<T>.LastIndexOf, e List<T>.Remove.

  • Metodi di ricerca della Dictionary<TKey,TValue> classe , inclusi ContainsKey e Remove.

  • Metodi di ricerca della classe generica LinkedList<T> , inclusi LinkedList<T>.Contains e Remove.

In altre parole, per gestire la possibilità che gli oggetti di una classe vengano archiviati in una matrice o in un oggetto raccolta generico, è consigliabile implementare IEquatable<T> in modo che l'oggetto possa essere facilmente identificato e modificato.

Quando si implementa il metodo, definire l'uguaglianza Equals in modo appropriato per il tipo specificato dall'argomento del tipo generico. Ad esempio, se l'argomento di tipo è Int32, definire l'uguaglianza in modo appropriato per il confronto di due interi con segno a 32 bit.

Note per gli implementatori

Se si implementa Equals(T), è anche necessario eseguire l'override delle implementazioni della classe di base di Equals(Object) e GetHashCode() in modo che il relativo comportamento sia coerente con quello del Equals(T) metodo . Se si esegue l'override di , l'implementazione sottoposta a override Equals(Object)viene chiamata anche nelle chiamate al metodo statico Equals(System.Object, System.Object) nella classe . Inoltre, è necessario eseguire l'overload degli op_Equality operatori e op_Inequality . In questo modo tutti i test di uguaglianza restituiscono risultati coerenti, come illustrato nell'esempio.