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

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

IEquatable.cs

Indica si el objeto actual es igual a otro objeto del mismo tipo.

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

other

T

Objeto que se va a comparar con este objeto.

Devoluciones

Boolean

true es si el objeto actual es igual al other parámetro ; en caso contrario, falsees .

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

Cuando se almacena en Person , List<T>Contains usa su Equals implementación para buscar una coincidencia.

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

Comentarios

La implementación del Equals método está pensada para realizar una prueba de igualdad con otro objeto de tipo T, el mismo tipo que el objeto actual. Se Equals(T) llama al método en las siguientes circunstancias:

• Cuando se llama al Equals método y el other argumento es un objeto fuertemente tipado de tipo T. (Si other no es de tipo T, se llama al método base Object.Equals(Object) . De los dos métodos, IEquatable<T>.Equals ofrece un rendimiento ligeramente mejor).

• Cuando se llama a los métodos de búsqueda de varios objetos de colección genéricos. Algunos de estos tipos y sus métodos incluyen lo siguiente:

  • Algunas de las sobrecargas genéricas del BinarySearch método .

  • Los métodos de búsqueda de la List<T> clase , incluidos List<T>.Contains(T), List<T>.IndexOf, List<T>.LastIndexOfy List<T>.Remove.

  • Los métodos de búsqueda de la Dictionary<TKey,TValue> clase , incluidos ContainsKey y Remove.

  • Los métodos de búsqueda de la clase genérica LinkedList<T> , incluidos LinkedList<T>.Contains y Remove.

Es decir, para controlar la posibilidad de que los objetos de una clase se almacenen en una matriz o en un objeto de colección genérico, es una buena idea implementar IEquatable<T> para que el objeto se pueda identificar y manipular fácilmente.

Al implementar el Equals método, defina la igualdad apropiadamente para el tipo especificado por el argumento de tipo genérico. Por ejemplo, si el argumento type es Int32, defina la igualdad adecuadamente para la comparación de dos enteros de 32 bits con signo.

Notas a los implementadores

Si implementa Equals(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, que se muestran en el ejemplo.