IEquatable<T>.Equals(T) Método

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

Parâmetros

Retornos

true se o objeto atual for igual ao other parâmetro; caso contrário, false.

Exemplos

O exemplo a seguir mostra a implementação parcial de uma Person classe que implementa IEquatable<T> e tem duas propriedades LastName e NationalId. NationalId é considerado um identificador exclusivo, portanto, o Equals método retorna True se a NationalId propriedade de dois Person objetos for idêntica; caso contrário, retornará False. (Observe que o exemplo F# não manipula null valores para Person instâncias.)

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 um Person é armazenado em um List<T>, Contains usa sua Equals implementação para pesquisar uma correspondência.

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

Comentários

A implementação do Equals método destina-se a executar um teste de igualdade com outro objeto de tipo T, o mesmo tipo que o objeto atual. O Equals(T) método é chamado nas seguintes circunstâncias:

• Quando o Equals método é chamado e o other argumento é um objeto fortemente tipado do tipo T. (Se other não for do tipo T, o método base Object.Equals(Object) será chamado. Dos dois métodos, IEquatable<T>.Equals oferece um desempenho ligeiramente melhor.)

• Quando os métodos de pesquisa de vários objetos de coleção genérica são chamados. Alguns desses tipos e seus métodos incluem o seguinte:

  • Algumas das sobrecargas genéricas do BinarySearch método.

  • Os métodos de pesquisa da List<T> classe, incluindo List<T>.Contains(T), List<T>.IndexOfe List<T>.LastIndexOfList<T>.Remove.

  • Os métodos de pesquisa da Dictionary<TKey,TValue> classe, incluindo ContainsKey e Remove.

  • Os métodos de pesquisa da classe genérica LinkedList<T> , incluindo LinkedList<T>.Contains e Remove.

Em outras palavras, para lidar com a possibilidade de que objetos de uma classe sejam armazenados em uma matriz ou em um objeto de coleção genérico, é uma boa ideia implementar IEquatable<T> para que o objeto possa ser facilmente identificado e manipulado.

Ao implementar o Equals método, defina a igualdade adequadamente para o tipo especificado pelo argumento de tipo genérico. Por exemplo, se o argumento de tipo for Int32, defina a igualdade adequadamente para a comparação de dois inteiros com sinal de 32 bits.

Notas aos Implementadores

Se você implementar Equals(T), você também deverá substituir as implementações de classe base de Equals(Object) e GetHashCode() para que seu comportamento seja consistente com o Equals(T) do método. Se você substituir Equals(Object), sua implementação substituída também será chamada em chamadas para o método estático Equals(System.Object, System.Object) em sua classe. Além disso, você deve sobrecarregar os operadores e op_Equality os op_Inequality operadores. Isso garante que todos os testes de igualdade retornem resultados consistentes, o que o exemplo ilustra.