IStructuralEquatable.Equals(Object, IEqualityComparer) Méthode

Définition

Espace de noms:

System.Collections

Assembly:

System.Runtime.dll

Détermine si un objet est structurellement identique à l'instance actuelle.

C#

public bool Equals (object? other, System.Collections.IEqualityComparer comparer);

Paramètres

other

Object

Objet à comparer à l’instance actuelle.

comparer

IEqualityComparer

Objet qui détermine si l’instance actuelle et other sont égales.

Retours

Boolean

true si les deux objets sont égaux ; sinon, false.

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 IStructuralEquatable . 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.

C#

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);
   }
}

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.

C#

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

Remarques

La Equals méthode prend en charge la comparaison structurelle personnalisée d’objets de tableau et de tuples. Cette méthode appelle à son tour la méthode de IEqualityComparer.Equals l’objet comparer pour comparer des éléments de tableau ou des composants de tuples individuels, en commençant par le premier élément ou composant. Les appels individuels à IEqualityComparer.Equals terminer et la IStructuralEquatable.Equals méthode retourne une valeur soit lorsqu’un appel de méthode retourne false , soit après que tous les éléments de tableau ou composants de tuple ont été comparés.

S’applique à

Voir aussi

• StructuralEqualityComparer