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

Devoluções

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

Exemplos

O exemplo seguinte mostra a implementação parcial de uma Person classe que implementa IEquatable<T> e tem duas propriedades, LastName e NationalId. NationalId é considerado um identificador único, portanto o Equals método devolve True se a NationalId propriedade de dois Person objetos for idêntica; caso contrário, devolve False. (Note que o exemplo de F# não trata null valores para Person as 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 a Person é armazenado num List<T>, Contains usa a sua Equals implementação para procurar 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

Observações

A implementação do Equals método destina-se a realizar um teste de igualdade com outro objeto do tipo T, o mesmo tipo do 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, chama-se o método base Object.Equals(Object) . Dos dois métodos, IEquatable<T>.Equals oferece um desempenho ligeiramente melhor.)

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

  • 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>.IndexOf, List<T>.LastIndexOf, e List<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.

Por outras palavras, para lidar com a possibilidade de objetos de uma classe serem armazenados num array ou num objeto genérico de coleção, é 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 genérico do tipo. Por exemplo, se o argumento do tipo for Int32, defina igualdade de forma apropriada para a comparação de dois inteiros assinados de 32 bits.

Notas para Implementadores

Se implementar Equals(T), deve também sobrescrever as implementações da classe base de Equals(Object) e GetHashCode() para que o seu comportamento seja consistente com o Equals(T) do método. Se fizeres override Equals(Object), a tua implementação overriden também é chamada em chamadas para o método estático Equals(System.Object, System.Object) na tua classe. Além disso, deve sobrecarregar os op_Equality operadores.op_Inequality Isto garante que todos os testes de igualdade retornam resultados consistentes, como ilustra o exemplo.