EqualityComparer<T>.Default Propriété

Définition

Espace de noms:

System.Collections.Generic

Assembly:

System.Collections.dll

Source:

EqualityComparer.CoreCLR.cs

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

C#

public static System.Collections.Generic.EqualityComparer<T> Default { get; }

Valeur de propriété

EqualityComparer<T>

Instance par défaut de la classe EqualityComparer<T> pour le type T.

Exemples

L’exemple suivant crée une collection qui contient des éléments du Box type, puis recherche une zone correspondant à une autre zone en appelant la FindFirst méthode, deux fois.

La première recherche ne spécifie aucun comparateur d’égalité, ce qui signifie utilise FindFirstEqualityComparer<T>.Default pour déterminer l’égalité des zones. Cela utilise à son tour l’implémentation de la IEquatable<T>.Equals méthode dans la Box classe . Deux cases sont considérées comme égales si leurs dimensions sont identiques.

La deuxième recherche spécifie un comparateur d’égalité (BoxEqVolume) qui définit l’égalité par volume. Deux zones sont considérées comme égales si leurs volumes sont identiques.

C#

using System;
using System.Collections.Generic;

static class Program
{
    static void Main()
    {
        var redBox = new Box(8, 8, 4);
        var blueBox = new Box(6, 8, 4);
        var greenBox = new Box(4, 8, 8);

        var boxes = new[] { redBox, blueBox, greenBox };

        var boxToFind = new Box(4, 8, 8);

        var foundByDimension = boxes.FindFirst(boxToFind);

        Console.WriteLine($"Found box {foundByDimension} by dimension.");

        var foundByVolume = boxes.FindFirst(boxToFind, new BoxEqVolume());

        Console.WriteLine($"Found box {foundByVolume} by volume.");
    }
}

public static class CollectionExtensions
{
    public static T FindFirst<T>(
        this IEnumerable<T> collection, T itemToFind, IEqualityComparer<T> comparer = null)
    {
        comparer = comparer ?? EqualityComparer<T>.Default;

        foreach (var item in collection)
        {
            if (comparer.Equals(item, itemToFind))
            {
                return item;
            }
        }

        throw new InvalidOperationException("No matching item found.");
    }
}

public class BoxEqVolume : EqualityComparer<Box>
{
    public override bool Equals(Box b1, Box b2)
    {
        if (object.ReferenceEquals(b1, b2))
            return true;

        if (b1 is null || b2 is null)
            return false;

        return b1.Volume == b2.Volume;
    }

    public override int GetHashCode(Box box) => box.Volume.GetHashCode();
}

public class Box : IEquatable<Box>
{
    public Box(int height, int length, int width)
    {
        this.Height = height;
        this.Length = length;
        this.Width = width;
    }

    public int Height { get; }
    public int Length { get; }
    public int Width { get; }

    public int Volume => Height * Length * Width;

    public bool Equals(Box other)
    {
        if (other is null)
            return false;

        return this.Height == other.Height && this.Length == other.Length
            && this.Width == other.Width;
    }

    public override bool Equals(object obj) => Equals(obj as Box);
    public override int GetHashCode() => (Height, Length, Width).GetHashCode();

    public override string ToString() => $"{Height} x {Length} x {Width}";
}

/* This example produces the following output:
 *
    Found box 4 x 8 x 8 by dimension.
    Found box 8 x 8 x 4 by volume.
 */

Remarques

La Default propriété vérifie si le type T implémente l’interface System.IEquatable<T> et, le cas échéant, retourne un EqualityComparer<T> qui utilise cette implémentation. Sinon, elle retourne un EqualityComparer<T> qui utilise les remplacements de Object.Equals et Object.GetHashCode fournis par T.

S’applique à

Voir aussi

• IEqualityComparer<T>
• IEquatable<T>
• Object