IStructuralEquatable IStructuralEquatable IStructuralEquatable IStructuralEquatable Interface

Définition

Définit les méthodes destinées à la prise en charge de la comparaison d'objets pour l'égalité structurelle.Defines methods to support the comparison of objects for structural equality.

public interface class IStructuralEquatable
public interface IStructuralEquatable
type IStructuralEquatable = interface
Public Interface IStructuralEquatable
Dérivé

Exemples

Le comparateur d’égalité EqualityComparer<Object>.Default.Equalspar défaut, NaN , considère que deux valeurs sont égales.The default equality comparer, EqualityComparer<Object>.Default.Equals, considers two NaN values to be equal. Toutefois, dans certains cas, vous souhaiterez peut-être NaN que la comparaison des valeurs falsed’égalité soit retournée, ce qui indique que les valeurs ne peuvent pas être comparées.However, in some cases, you may want the comparison of NaN values for equality to return false, which indicates that the values cannot be compared. L'exemple suivant définit une classe NanComparer qui implémente l'interface IStructuralEquatable .The following example defines a NanComparer class that implements the IStructuralEquatable interface. Il compare deux Double ou deux Single valeurs en utilisant l’opérateur d’égalité.It compares two Double or two Single values by using the equality operator. Il passe les valeurs de tout autre type au comparateur d’égalité par défaut.It passes values of any other type to the default equality comparer.

using System;
using System.Collections;
using System.Collections.Generic;

public class NanComparer : IEqualityComparer
{
   public new bool Equals(object x, object y)
   {
      if (x is float)
         return (float) x == (float) y;
      else if (x is double)
         return (double) x == (double) y;
      else
         return EqualityComparer<object>.Default.Equals(x, y);
   }
   
   public int GetHashCode(object obj)
   {
      return EqualityComparer<object>.Default.GetHashCode(obj);
   }
}
Imports System.Collections
Imports System.Collections.Generic

Public Class NanComparer : Implements IEqualityComparer
   Public Overloads Function Equals(x As Object, y As Object) As Boolean _
          Implements IEqualityComparer.Equals
      If TypeOf x Is Single Then
         Return CSng(x) = CSng(y)
      ElseIf TypeOf x Is Double Then
         Return CDbl(x) = CDbl(y)
      Else
         Return EqualityComparer(Of Object).Default.Equals(x, y)
      End If
   End Function
   
   Public Overloads Function GetHashCode(obj As Object) As Integer _
          Implements IEqualityComparer.GetHashCode
      Return EqualityComparer(Of Object).Default.GetHashCode(obj)
   End Function
End Class

L’exemple suivant crée deux objets de 3 tuples identiques dont les composants se Double composent de trois valeurs.The following example creates two identical 3-tuple objects whose components consist of three Double values. La valeur du deuxième composant est Double.NaN.The value of the second component is Double.NaN. L’exemple appelle ensuite la Tuple<T1,T2,T3>.Equals méthode et appelle la IStructuralEquatable.Equals méthode trois fois.The example then calls the Tuple<T1,T2,T3>.Equals method, and it calls the IStructuralEquatable.Equals method three times. La première fois, elle passe le comparateur d’égalité par défaut retourné par EqualityComparer<T>.Default la propriété.The first time, it passes the default equality comparer that is returned by the EqualityComparer<T>.Default property. La deuxième fois, il passe le comparateur d’égalité par défaut retourné par StructuralComparisons.StructuralEqualityComparer la propriété.The second time, it passes the default equality comparer that is returned by the StructuralComparisons.StructuralEqualityComparer property. La troisième fois, elle passe l’objet NanComparer personnalisé.The third time, it passes the custom NanComparer object. Comme le montre la sortie de l’exemple, les trois premiers appels de trueméthode retournent, tandis que le quatrième appel retourne. falseAs the output from the example shows, the first three method calls return true, whereas the fourth call returns false.

public class Example
{
   public static void Main()
   {
      var t1 = Tuple.Create(12.3, Double.NaN, 16.4);
      var t2 = Tuple.Create(12.3, Double.NaN, 16.4);
      
      // Call default Equals method.
      Console.WriteLine(t1.Equals(t2));
      
      IStructuralEquatable equ = t1;
      // Call IStructuralEquatable.Equals using default comparer.
      Console.WriteLine(equ.Equals(t2, EqualityComparer<object>.Default));
      
      // Call IStructuralEquatable.Equals using 
      // StructuralComparisons.StructuralEqualityComparer.
      Console.WriteLine(equ.Equals(t2, 
                        StructuralComparisons.StructuralEqualityComparer));
      
      // Call IStructuralEquatable.Equals using custom comparer.
      Console.WriteLine(equ.Equals(t2, new NanComparer()));
   }
}
// The example displays the following output:
//       True
//       True
//       True
//       False
Module Example
   Public Sub Main()
      Dim t1 = Tuple.Create(12.3, Double.NaN, 16.4)
      Dim t2 = Tuple.Create(12.3, Double.NaN, 16.4)
      
      ' Call default Equals method.
      Console.WriteLine(t1.Equals(t2))
      
      Dim equ As IStructuralEquatable = t1
      ' Call IStructuralEquatable.Equals using default comparer.
      Console.WriteLine(equ.Equals(t2, EqualityComparer(Of Object).Default))
      
      ' Call IStructuralEquatable.Equals using 
      ' StructuralComparisons.StructuralEqualityComparer.
      Console.WriteLine(equ.Equals(t2, 
                        StructuralComparisons.StructuralEqualityComparer))
      
      ' Call IStructuralEquatable.Equals using custom comparer.
      Console.WriteLine(equ.Equals(t2, New NanComparer))
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       True
'       False

Remarques

L’égalité structurelle signifie que deux objets sont égaux, car ils ont des valeurs égales.Structural equality means that two objects are equal because they have equal values. Il diffère de l’égalité de référence, qui indique que deux références d’objet sont égales, car elles référencent le même objet physique.It differs from reference equality, which indicates that two object references are equal because they reference the same physical object. L' IStructuralEquatable interface vous permet d’implémenter des comparaisons personnalisées pour vérifier l’égalité structurelle des objets de collection.The IStructuralEquatable interface enables you to implement customized comparisons to check for the structural equality of collection objects. Autrement dit, vous pouvez créer votre propre définition d’égalité structurelle et spécifier que cette définition doit être utilisée avec un type de collection qui IStructuralEquatable accepte l’interface.That is, you can create your own definition of structural equality and specify that this definition be used with a collection type that accepts the IStructuralEquatable interface. L’interface possède deux membres: Equals, qui teste l’égalité à l’aide IEqualityComparer d’une implémentation GetHashCodespécifiée, et, qui retourne des codes de hachage identiques pour les objets qui sont égaux.The interface has two members: Equals, which tests for equality by using a specified IEqualityComparer implementation, and GetHashCode, which returns identical hash codes for objects that are equal.

Notes

L' IStructuralEquatable interface prend en charge uniquement les comparaisons personnalisées pour l’égalité structurelle.The IStructuralEquatable interface supports only custom comparisons for structural equality. L' IStructuralComparable interface prend en charge les comparaisons structurelles personnalisées pour le tri et le classement.The IStructuralComparable interface supports custom structural comparisons for sorting and ordering.

Le .NET Framework fournit également des comparateurs d’égalité par défaut, qui sont EqualityComparer<T>.Default retournés par les propriétés et. StructuralComparisons.StructuralEqualityComparerThe .NET Framework also provides default equality comparers, which are returned by the EqualityComparer<T>.Default and StructuralComparisons.StructuralEqualityComparer properties. Pour plus d’informations, consultez l’exemple.For more information, see the example.

Les classes de tuple génériquesTuple<T1>( Tuple<T1,T2>, Tuple<T1,T2,T3>,, etc.) et la Array classe fournissent des implémentations explicites IStructuralEquatable de l’interface.The generic tuple classes (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, and so on) and the Array class provide explicit implementations of the IStructuralEquatable interface. En castant ( C#en) ou en convertissant (en Visual Basic) l’instance actuelle d’un tableau ou d' IStructuralEquatable un tuple en une valeur IEqualityComparer d’interface et en fournissant votre Equals implémentation comme argument à la méthode, vous pouvez définir une égalité personnalisée comparaison pour le tableau ou la collection.By casting (in C#) or converting (in Visual Basic) the current instance of an array or tuple to an IStructuralEquatable interface value and providing your IEqualityComparer implementation as an argument to the Equals method, you can define a custom equality comparison for the array or collection.

Méthodes

Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer) Equals(Object, IEqualityComparer)

Détermine si un objet est structurellement identique à l'instance actuelle.Determines whether an object is structurally equal to the current instance.

GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer) GetHashCode(IEqualityComparer)

Retourne un code de hachage pour l'instance actuelle.Returns a hash code for the current instance.

S’applique à

Voir aussi