EqualityComparer<T> Classe

Définition

Espace de noms:

System.Collections.Generic

Assembly:

System.Collections.dll

Source:

EqualityComparer.CoreCLR.cs

Fournit une classe de base pour les implémentations de l'interface générique IEqualityComparer<T>.

C#

public abstract class EqualityComparer<T> : System.Collections.Generic.IEqualityComparer<T>, System.Collections.IEqualityComparer

Paramètres de type

T

Type des objets à comparer.

Héritage

Object

EqualityComparer<T>

Implémente

IEqualityComparer<T> IEqualityComparer

Exemples

L’exemple suivant crée une collection de dictionnaires d’objets de type Box avec un comparateur d’égalité. Deux zones sont considérées comme égales si leurs dimensions sont identiques. Il ajoute ensuite les zones à la collection.

Le dictionnaire est recréé avec un comparateur d’égalité qui définit l’égalité de manière différente : deux zones sont considérées comme égales si leurs volumes sont identiques.

C#

using System;
using System.Collections.Generic;

class Program
{
    static Dictionary<Box, String> boxes;

    static void Main()
    {
        BoxSameDimensions boxDim = new BoxSameDimensions();
        boxes = new Dictionary<Box, string>(boxDim);

        Console.WriteLine("Boxes equality by dimensions:");
        Box redBox = new Box(8, 4, 8);
        Box greenBox = new Box(8, 6, 8);
        Box blueBox = new Box(8, 4, 8);
        Box yellowBox = new Box(8, 8, 8);
        AddBox(redBox, "red");
        AddBox(greenBox, "green");
        AddBox(blueBox, "blue");
        AddBox(yellowBox, "yellow");

        Console.WriteLine();
        Console.WriteLine("Boxes equality by volume:");

        BoxSameVolume boxVolume = new BoxSameVolume();
        boxes = new Dictionary<Box, string>(boxVolume);
        Box pinkBox = new Box(8, 4, 8);
        Box orangeBox = new Box(8, 6, 8);
        Box purpleBox = new Box(4, 8, 8);
        Box brownBox = new Box(8, 8, 4);
        AddBox(pinkBox, "pink");
        AddBox(orangeBox, "orange");
        AddBox(purpleBox, "purple");
        AddBox(brownBox, "brown");
    }

    public static void AddBox(Box bx, string name)
    {
        try
        {
            boxes.Add(bx, name);
            Console.WriteLine("Added {0}, Count = {1}, HashCode = {2}",
                name, boxes.Count.ToString(), bx.GetHashCode());
        }
        catch (ArgumentException)
        {
            Console.WriteLine("A box equal to {0} is already in the collection.", name);
        }
    }
}

public class Box
{
    public Box(int h, int l, int w)
    {
        this.Height = h;
        this.Length = l;
        this.Width = w;
    }
    public int Height { get; set; }
    public int Length { get; set; }
    public int Width { get; set; }
}

class BoxSameDimensions : EqualityComparer<Box>
{
    public override bool Equals(Box b1, Box b2)
    {
        if (b1 == null && b2 == null)
            return true;
        else if (b1 == null || b2 == null)
            return false;

        return (b1.Height == b2.Height &&
                b1.Length == b2.Length &&
                b1.Width == b2.Width);
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        return hCode.GetHashCode();
    }
}

class BoxSameVolume : EqualityComparer<Box>
{
    public override bool Equals(Box b1, Box b2)
    {
        if (b1 == null && b2 == null)
            return true;
        else if (b1 == null || b2 == null)
            return false;

        return (b1.Height * b1.Width * b1.Length ==
                b2.Height * b2.Width * b2.Length);
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height * bx.Length * bx.Width;
        return hCode.GetHashCode();
    }
}
/* This example produces an output similar to the following:
 *
      Boxes equality by dimensions:
      Added red, Count = 1, HashCode = 46104728
      Added green, Count = 2, HashCode = 12289376
      A box equal to blue is already in the collection.
      Added yellow, Count = 3, HashCode = 43495525

      Boxes equality by volume:
      Added pink, Count = 1, HashCode = 55915408
      Added orange, Count = 2, HashCode = 33476626
      A box equal to purple is already in the collection.
      A box equal to brown is already in the collection.
 *
*/

Remarques

Dérivez de cette classe pour fournir une implémentation personnalisée de l’interface IEqualityComparer<T> générique à utiliser avec des classes de collection telles que la Dictionary<TKey,TValue> classe générique, ou avec des méthodes telles que List<T>.Sort.

La Default propriété vérifie si le type T implémente l’interface System.IEquatable<T> générique et, le cas échéant, retourne un EqualityComparer<T> qui appelle l’implémentation de la IEquatable<T>.Equals méthode. Sinon, il retourne un EqualityComparer<T>, comme fourni par T.

Dans .NET 8 et versions ultérieures, nous vous recommandons d’utiliser la EqualityComparer<T>.Create(Func<T,T,Boolean>, Func<T,Int32>) méthode pour créer des instances de ce type.

Constructeurs

EqualityComparer<T>()

Initialise une nouvelle instance de la classe EqualityComparer<T>.

Propriétés

Default

Retourne un comparateur d’égalité par défaut pour le type spécifié par l’argument générique.

Méthodes

Create(Func<T,T,Boolean>, Func<T,Int32>)	Crée un EqualityComparer<T> en utilisant les délégués spécifiés comme implémentation des méthodes et GetHashCode(T) du Equals(T, T) comparateur.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Equals(T, T)	En cas de substitution dans une classe dérivée, détermine si deux objets de type T sont égaux.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetHashCode(T)	En cas de substitution dans une classe dérivée, sert de fonction de hachage pour l'objet spécifié pour le hachage d'algorithmes et des structures de données, telles qu'une table de hachage.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

IEqualityComparer.Equals(Object, Object)	Détermine si les objets spécifiés sont égaux.
IEqualityComparer.GetHashCode(Object)	Retourne un code de hachage pour l'objet spécifié.

S’applique à

Voir aussi

• IEqualityComparer<T>
• IEquatable<T>