Partager via

IStructuralEquatable Interface

  • Référence

Définition

Espace de noms:
System.Collections
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Définit des méthodes pour prendre en charge la comparaison de la structure d'objets.

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

Exemples

Le comparateur d’égalité par défaut, EqualityComparer<Object>.Default.Equals, considère que deux NaN valeurs sont égales. Toutefois, dans certains cas, vous pouvez souhaiter que la comparaison des valeurs d’égalité NaN retourne false, ce qui indique que les valeurs ne peuvent pas être comparées. L'exemple suivant définit une classe NanComparer qui implémente l'interface IEqualityComparer . Il est utilisé par le troisième exemple comme argument de la Equals(Object, IEqualityComparer) méthode de l’interface IStructuralEquatable que les tuples implémentent. Il compare deux Double ou deux Single valeurs à l’aide de l’opérateur d’égalité. Il transmet les valeurs de tout autre type au comparateur d’égalité par défaut.

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 identiques à 3 tuples dont les composants se composent de trois Double valeurs. La valeur du deuxième composant est Double.NaN. L’exemple appelle ensuite la Tuple<T1,T2,T3>.Equals méthode et la IStructuralEquatable.Equals méthode trois fois. La première fois, il transmet le comparateur d’égalité par défaut retourné par la EqualityComparer<T>.Default propriété . La deuxième fois, il transmet le comparateur d’égalité par défaut retourné par la StructuralComparisons.StructuralEqualityComparer propriété . La troisième fois, il transmet l’objet personnalisé NanComparer . Comme le montre la sortie de l’exemple, les trois premiers appels de méthode retournent true, tandis que le quatrième appel retourne 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. Il diffère de l’égalité de référence, qui indique que deux références d’objet sont égales, car elles font référence au même objet physique. L’interface IStructuralEquatable vous permet d’implémenter des comparaisons personnalisées pour vérifier l’égalité structurelle des objets de collection. 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 accepte l’interface IStructuralEquatable . L’interface a deux membres : Equals, qui teste l’égalité à l’aide d’une implémentation spécifiée IEqualityComparer , et GetHashCode, qui retourne des codes de hachage identiques pour les objets égaux.

Notes

L’interface IStructuralEquatable prend uniquement en charge les comparaisons personnalisées pour l’égalité structurelle. L’interface IStructuralComparable prend en charge les comparaisons structurelles personnalisées pour le tri et l’ordre.

Le .NET Framework fournit également des comparateurs d’égalité par défaut, qui sont retournés par les EqualityComparer<T>.Default propriétés et StructuralComparisons.StructuralEqualityComparer . Pour plus d'informations, reportez-vous à l'exemple.

Les classes tuples génériques (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>, etc.) et la Array classe fournissent des implémentations explicites de l’interface IStructuralEquatable . En convertissant (en C#) ou en convertissant (en Visual Basic) l’instance actuelle d’un tableau ou d’un tuple en valeur d’interface IStructuralEquatable et en fournissant votre IEqualityComparer implémentation en tant qu’argument de la Equals méthode, vous pouvez définir une comparaison d’égalité personnalisée pour le tableau ou la collection.

Méthodes

Equals(Object, IEqualityComparer)

Détermine si un objet est structurellement identique à l'instance actuelle.
GetHashCode(IEqualityComparer)

Retourne un code de hachage pour l'instance actuelle.

S’applique à

Voir aussi