IEquatable<T> Interfaz
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Define un método generalizado que implementa un tipo de valor o clase para crear un método específico del tipo para determinar la igualdad de instancias.
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
- T
Tipo de objetos que se van a comparar.
- Derivado
Ejemplos
En el ejemplo siguiente se muestra la implementación parcial de una Person clase que implementa IEquatable<T> y tiene dos propiedades, LastName y NationalId.
NationalId se considera un identificador único, por lo que el Equals método devuelve True si la NationalId propiedad de dos Person objetos es idéntica; de lo contrario, devuelve False.
(Tenga en cuenta que el ejemplo de F# no controla null los valores de Person las instancias).
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
Comentarios
Esta interfaz se implementa mediante tipos cuyos valores se pueden comparar (por ejemplo, las clases numéricas y de cadena). Un tipo de valor o clase implementa el Equals método para crear un método específico del tipo adecuado para determinar la igualdad de instancias.
Nota
La IComparable<T> interfaz define el CompareTo método , que determina el criterio de ordenación de las instancias del tipo de implementación. La IEquatable<T> interfaz define el Equals método , que determina la igualdad de instancias del tipo de implementación.
La IEquatable<T> interfaz se usa en objetos de colección genéricos como Dictionary<TKey,TValue>, List<T>y LinkedList<T> al probar la igualdad en métodos como Contains, IndexOf, LastIndexOfy Remove. Debe implementarse para cualquier objeto que se pueda almacenar en una colección genérica.
Para obtener más información sobre la implementación de la IEquatable<T> interfaz, vea los comentarios sobre el IEquatable<T>.Equals método .
Notas a los implementadores
Reemplace el parámetro type de la IEquatable<T> interfaz por el tipo que implementa esta interfaz.
Si implementa IEquatable<T>, también debe invalidar las implementaciones de clase base de Equals(Object) y GetHashCode() para que su comportamiento sea coherente con el Equals(T) del método . Si reemplaza Equals(Object), también se llama a la implementación invalidada en llamadas al método estático Equals(System.Object, System.Object) de la clase . Además, debe sobrecargar los op_Equality operadores y op_Inequality . Esto garantiza que todas las pruebas de igualdad devuelvan resultados coherentes.
Para obtener información sobre cómo invalidar Equals(Object), vea Equals(Object).
Para un tipo de valor, siempre debe implementar IEquatable<T> e invalidar Equals(Object) para mejorar el rendimiento. Equals(Object) boxes tipos de valor y se basa en la reflexión para comparar dos valores para la igualdad. Tanto la implementación de como la invalidación de Equals(T)Equals(Object) deben devolver resultados coherentes.
Si implementa , también debe implementar IEquatable<T>IComparable<T> si las instancias del tipo se pueden ordenar o ordenar. Si el tipo implementa IComparable<T>, casi siempre también implementará IEquatable<T>.
Tenga en cuenta que hay algunos diseños en los que un tipo admite una relación de pedido, pero la igualdad puede ser distinta de una relación de ordenación. Considere una Person clase en la que se ordena alfabéticamente. Dos personas con el mismo nombre ordenan lo mismo, pero no son la misma persona.
Métodos
| Nombre | Description |
|---|---|
| Equals(T) |
Indica si el objeto actual es igual a otro objeto del mismo tipo. |
