IEquatable<T>.Equals(T) Metod

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

Parametrar

Returer

trueom det aktuella objektet är lika med parameternother, annars . false

Exempel

I följande exempel visas den partiella implementeringen av en Person klass som implementerar IEquatable<T> och har två egenskaper, LastName och NationalId. NationalId anses vara en unik identifierare, därför Equals returnerar True metoden om NationalId egenskapen för två Person objekt är identisk. Annars returneras False. (Observera att F#-exemplet inte hanterar null värden för Person instanser.)

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

När en Person lagras i en List<T>använder Contains dess Equals implementering för att söka efter en matchning.

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

Kommentarer

Implementeringen av Equals metoden är avsedd att utföra ett test för likhet med ett annat objekt av typen T, samma typ som det aktuella objektet. Metoden Equals(T) anropas under följande omständigheter:

• Equals När metoden anropas och other argumentet är ett starkt skrivet objekt av typen T. (Om other inte är av typen Tanropas basmetoden Object.Equals(Object) . Av de två metoderna IEquatable<T>.Equals ger något bättre prestanda.)

• När sökmetoderna för ett antal generiska samlingsobjekt anropas. Några av dessa typer och deras metoder omfattar följande:

  • Några av de allmänna överlagringarna av BinarySearch metoden.

  • Sökmetoderna för List<T> klassen, inklusive List<T>.Contains(T), List<T>.IndexOf, List<T>.LastIndexOfoch List<T>.Remove.

  • Sökmetoderna för Dictionary<TKey,TValue> klassen, inklusive ContainsKey och Remove.

  • Sökmetoderna för den generiska LinkedList<T> klassen, inklusive LinkedList<T>.Contains och Remove.

För att hantera möjligheten att objekt i en klass lagras i en matris eller ett generiskt samlingsobjekt är det med andra ord en bra idé att implementera IEquatable<T> så att objektet enkelt kan identifieras och manipuleras.

När du implementerar Equals metoden definierar du likhet på lämpligt sätt för den typ som anges av argumentet för allmän typ. Om typargumentet till exempel är Int32definierar du likhet på lämpligt sätt för jämförelsen av två 32-bitars signerade heltal.

Anteckningar till implementerare

Om du implementerar Equals(T)bör du också åsidosätta basklassimplementeringarna för Equals(Object) och GetHashCode() så att deras beteende överensstämmer med Equals(T) metodens. Om du åsidosätter Equals(Object)anropas även den åsidosättna implementeringen i anrop till den statiska Equals(System.Object, System.Object) metoden i klassen. Dessutom bör du överbelasta operatorerna op_Equality och op_Inequality . Detta säkerställer att alla tester för likhet returnerar konsekventa resultat, vilket exemplet illustrerar.