# IEquatable<T>.Equals(T) Méthode

## Définition

Indique si l'objet actuel est égal à un autre objet du même type.Indicates whether the current object is equal to another object of the same type.

``````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``

#### Paramètres

other
T

Objet à comparer à cet objet.An object to compare with this object.

#### Retours

Boolean

`true` si l'objet actuel est égal au paramètre `other` ; sinon, `false`.`true` if the current object is equal to the `other` parameter; otherwise, `false`.

## Exemples

L’exemple suivant montre l’implémentation partielle d’une `Person` classe qui implémente IEquatable<T> et a deux propriétés, `LastName` et `SSN` .The following example shows the partial implementation of a `Person` class that implements IEquatable<T> and has two properties, `LastName` and `SSN`. La Equals méthode retourne `True` si la `SSN` propriété de deux `Person` objets est identique ; sinon, elle retourne `False` .The Equals method returns `True` if the `SSN` property of two `Person` objects is identical; otherwise, it returns `False`.

``````using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Person : IEquatable<Person>
{
private string uniqueSsn;
private string lName;

public Person(string lastName, string ssn)
{
if (Regex.IsMatch(ssn, @"\d{9}"))
uniqueSsn = \$"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}";
else if (Regex.IsMatch(ssn, @"\d{3}-\d{2}-\d{4}"))
uniqueSsn = ssn;
else
throw new FormatException("The social security number has an invalid format.");

this.LastName = lastName;
}

public string SSN
{
get { return this.uniqueSsn; }
}

public string LastName
{
get { return this.lName; }
set {
if (String.IsNullOrEmpty(value))
throw new ArgumentException("The last name cannot be null or empty.");
else
this.lName = value;
}
}

public bool Equals(Person other)
{
if (other == null)
return false;

if (this.uniqueSsn == other.uniqueSsn)
return true;
else
return false;
}

public override bool Equals(Object obj)
{
if (obj == null)
return false;

Person personObj = obj as Person;
if (personObj == null)
return false;
else
return Equals(personObj);
}

public override int GetHashCode()
{
return this.SSN.GetHashCode();
}

public static bool operator == (Person person1, Person person2)
{
if (((object)person1) == null || ((object)person2) == null)
return Object.Equals(person1, person2);

return person1.Equals(person2);
}

public static bool operator != (Person person1, Person person2)
{
if (((object)person1) == null || ((object)person2) == null)
return ! Object.Equals(person1, person2);

return ! (person1.Equals(person2));
}
}
``````
``````Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Public Class Person : Implements IEquatable(Of Person)
Private uniqueSsn As String
Private lName As String

Public Sub New(lastName As String, ssn As String)
If Regex.IsMatch(ssn, "\d{9}") Then
uniqueSsn = \$"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}"
ElseIf Regex.IsMatch(ssn, "\d{3}-\d{2}-\d{4}") Then
uniqueSsn = ssn
Else
Throw New FormatException("The social security number has an invalid format.")
End If
Me.LastName = lastName
End Sub

Public ReadOnly Property SSN As String
Get
Return Me.uniqueSsn
End Get
End Property

Public Property LastName As String
Get
Return Me.lName
End Get
Set
If String.IsNullOrEmpty(value) Then
Throw New ArgumentException("The last name cannot be null or empty.")
Else
lname = value
End If
End Set
End Property

Public Overloads Function Equals(other As Person) As Boolean _
Implements IEquatable(Of Person).Equals
If other Is Nothing Then Return False

If Me.uniqueSsn = other.uniqueSsn Then
Return True
Else
Return False
End If
End Function

Public Overrides Function Equals(obj As Object) As Boolean
If obj Is Nothing Then Return False

Dim personObj As Person = TryCast(obj, Person)
If personObj Is Nothing Then
Return False
Else
Return Equals(personObj)
End If
End Function

Public Overrides Function GetHashCode() As Integer
Return Me.SSN.GetHashCode()
End Function

Public Shared Operator = (person1 As Person, person2 As Person) As Boolean
If person1 Is Nothing OrElse person2 Is Nothing Then
Return Object.Equals(person1, person2)
End If

Return person1.Equals(person2)
End Operator

Public Shared Operator <> (person1 As Person, person2 As Person) As Boolean
If person1 Is Nothing OrElse person2 Is Nothing Then
Return Not Object.Equals(person1, person2)
End If

Return Not person1.Equals(person2)
End Operator
End Class
``````

`Person` les objets peuvent ensuite être stockés dans un List<T> objet et peuvent être identifiés par la `Contains` méthode, comme le montre l’exemple suivant.`Person` objects can then be stored in a List<T> object and can be identified by the `Contains` method, as the following example shows.

``````public class TestIEquatable
{
public static void Main()
{
// Create a Person object for each job applicant.
Person applicant1 = new Person("Jones", "099-29-4999");
Person applicant2 = new Person("Jones", "199-29-3999");
Person applicant3 = new Person("Jones", "299-49-6999");

// Add applicants to a List object.
List<Person> applicants = new List<Person>();

// Create a Person object for the final candidate.
Person candidate = new Person("Jones", "199-29-3999");
if (applicants.Contains(candidate))
Console.WriteLine("Found {0} (SSN {1}).",
candidate.LastName, candidate.SSN);
else

// Call the shared inherited Equals(Object, Object) method.
// It will in turn call the IEquatable(Of T).Equals implementation.
applicant2.LastName,
applicant2.SSN,
Person.Equals(applicant2, candidate));
}
}
// The example displays the following output:
//       Found Jones (SSN 199-29-3999).
//       Jones(199-29-3999) already on file: True.
``````
``````Module TestIEquatable
Public Sub Main()
' Create a Person object for each job applicant.
Dim applicant1 As New Person("Jones", "099-29-4999")
Dim applicant2 As New Person("Jones", "199-29-3999")
Dim applicant3 As New Person("Jones", "299-49-6999")

' Add applicants to a List object.
Dim applicants As New List(Of Person)

' Create a Person object for the final candidate.
Dim candidate As New Person("Jones", "199-29-3999")

If applicants.Contains(candidate) Then
Console.WriteLine("Found {0} (SSN {1}).", _
candidate.LastName, candidate.SSN)
Else
End If

' Call the shared inherited Equals(Object, Object) method.
' It will in turn call the IEquatable(Of T).Equals implementation.
Console.WriteLine("{0}({1}) already on file: {2}.", _
applicant2.LastName, _
applicant2.SSN, _
Person.Equals(applicant2, candidate))
End Sub
End Module
' The example displays the following output:
'       Found Jones (SSN 199-29-3999).
'       Jones(199-29-3999) already on file: True.
``````

## Remarques

L’implémentation de la Equals méthode est conçue pour effectuer un test d’égalité avec un autre objet de type `T` , le même type que l’objet actuel.The implementation of the Equals method is intended to perform a test for equality with another object of type `T`, the same type as the current object. La Equals(T) méthode est appelée dans les circonstances suivantes :The Equals(T) method is called in the following circumstances:

En d’autres termes, pour gérer la possibilité que les objets d’une classe soient stockés dans un tableau ou un objet de collection générique, il est préférable d’implémenter IEquatable<T> afin que l’objet puisse être facilement identifié et manipulé.In other words, to handle the possibility that objects of a class will be stored in an array or a generic collection object, it is a good idea to implement IEquatable<T> so that the object can be easily identified and manipulated.

Lors de l’implémentation de la Equals méthode, définissez l’égalité de manière appropriée pour le type spécifié par l’argument de type générique.When implementing the Equals method, define equality appropriately for the type specified by the generic type argument. Par exemple, si l’argument de type est Int32 , définissez l’égalité de manière appropriée pour la comparaison des entiers signés 2 32 bits.For example, if the type argument is Int32, define equality appropriately for the comparison of two 32-bit signed integers.

## Notes pour les responsables de l’implémentation

Si vous implémentez Equals(T) , vous devez également substituer les implémentations de classe de base de Equals(Object) et GetHashCode() afin que leur comportement soit cohérent avec celui de la Equals(T) méthode.If you implement Equals(T), you should also override the base class implementations of Equals(Object) and GetHashCode() so that their behavior is consistent with that of the Equals(T) method. Si vous substituez Equals(Object) , votre implémentation substituée est également appelée dans les appels à la `Equals(System.Object, System.Object)` méthode statique sur votre classe.If you do override Equals(Object), your overridden implementation is also called in calls to the static `Equals(System.Object, System.Object)` method on your class. En outre, vous devez surcharger les `op_Equality` `op_Inequality` opérateurs et.In addition, you should overload the `op_Equality` and `op_Inequality` operators. Cela garantit que tous les tests d’égalité retournent des résultats cohérents, comme l’illustre l’exemple.This ensures that all tests for equality return consistent results, which the example illustrates.