IEquatable<T> Interface
Definição
Importante
Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.
Define um método generalizado que um tipo de valor ou classe implementa para criar um método específico de tipo para determinar a igualdade de instâncias.
generic <typename T>
public interface class IEquatablepublic interface IEquatable<T>public interface IEquatable<T> where T : allows ref structtype IEquatable<'T> = interfacePublic Interface IEquatable(Of T)Parâmetros de Tipo Genérico
- T
O tipo de objetos a comparar.
- Derivado
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
Observações
Esta interface é implementada por tipos cujos valores podem ser igualados (por exemplo, as classes numéricas e de cadeia). Um tipo de valor ou classe implementa o Equals método para criar um método específico de tipo adequado para determinar a igualdade de instâncias.
Note
A IComparable<T> interface define o CompareTo método, que determina a ordem de ordenação das instâncias do tipo de implementação. A IEquatable<T> interface define o Equals método, que determina a igualdade das instâncias do tipo de implementação.
A IEquatable<T> interface é usada por objetos genéricos de coleção como Dictionary<TKey,TValue>, List<T>, e LinkedList<T> ao testar a igualdade em métodos como Contains, IndexOf, LastIndexOf, e Remove. Deve ser implementado para qualquer objeto que possa estar armazenado numa coleção genérica.
Para mais informações sobre a implementação da IEquatable<T> interface, consulte as observações sobre o IEquatable<T>.Equals método.
Notas para Implementadores
Substitua o parâmetro de tipo da IEquatable<T> interface pelo tipo que está a implementar esta interface.
Se implementar IEquatable<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.
Para informações sobre sobreposição Equals(Object), veja Equals(Object).
Para um tipo de valor, deve sempre implementar IEquatable<T> e sobreescrever Equals(Object) para melhor desempenho. Equals(Object) Caixas valorizam os tipos e baseiam-se na reflexão para comparar dois valores para igualdade. Tanto a sua implementação como Equals(T) a sobreposição deverão Equals(Object) devolver resultados consistentes.
Se implementares IEquatable<T>, também deves implementar IComparable<T> se instâncias do teu tipo podem ser ordenadas ou ordenadas. Se o teu tipo implementa IComparable<T>, quase sempre também implementas IEquatable<T>.
Note-se que existem alguns desenhos em que um tipo suporta uma relação de ordem, mas a igualdade pode ser distinta de uma relação de ordenação. Considera uma Person aula onde ordenas por ordem alfabética. Duas pessoas com o mesmo nome têm a mesma forma, mas não são a mesma pessoa.
Métodos
| Name | Description |
|---|---|
| Equals(T) |
Indica se o objeto atual é igual a outro objeto do mesmo tipo. |
