Comparer<T> Classe

public abstract class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer

[System.Serializable]
public abstract class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer

Héritage

Object

Comparer<T>

Attributs

SerializableAttribute

Implémente

IComparer<T> IComparer

L’exemple suivant dérive une classe, BoxLengthFirst, de la Comparer<T> classe . Ce comparateur compare deux objets de type Box. Il les trie d’abord par longueur, puis par hauteur, puis par largeur. La Box classe implémente l’interface IComparable<T> pour contrôler la comparaison par défaut entre deux Box objets. Cette implémentation par défaut trie d’abord par hauteur, puis par longueur, puis par largeur. L’exemple montre les différences entre les deux comparaisons en triant d’abord une liste d’objets à l’aide du BoxBoxLengthFirst comparateur, puis à l’aide du comparateur par défaut.

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

class Program
{
    static void Main(string[] args)
    {
        List<Box> Boxes = new List<Box>();
        Boxes.Add(new Box(4, 20, 14));
        Boxes.Add(new Box(12, 12, 12));
        Boxes.Add(new Box(8, 20, 10));
        Boxes.Add(new Box(6, 10, 2));
        Boxes.Add(new Box(2, 8, 4));
        Boxes.Add(new Box(2, 6, 8));
        Boxes.Add(new Box(4, 12, 20));
        Boxes.Add(new Box(18, 10, 4));
        Boxes.Add(new Box(24, 4, 18));
        Boxes.Add(new Box(10, 4, 16));
        Boxes.Add(new Box(10, 2, 10));
        Boxes.Add(new Box(6, 18, 2));
        Boxes.Add(new Box(8, 12, 4));
        Boxes.Add(new Box(12, 10, 8));
        Boxes.Add(new Box(14, 6, 6));
        Boxes.Add(new Box(16, 6, 16));
        Boxes.Add(new Box(2, 8, 12));
        Boxes.Add(new Box(4, 24, 8));
        Boxes.Add(new Box(8, 6, 20));
        Boxes.Add(new Box(18, 18, 12));

        // Sort by an Comparer<T> implementation that sorts
        // first by the length.
        Boxes.Sort(new BoxLengthFirst());

        Console.WriteLine("H - L - W");
        Console.WriteLine("==========");
        foreach (Box bx in Boxes)
        {
            Console.WriteLine("{0}\t{1}\t{2}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString());
        }

        Console.WriteLine();
        Console.WriteLine("H - L - W");
        Console.WriteLine("==========");

        // Get the default comparer that
        // sorts first by the height.
        Comparer<Box> defComp = Comparer<Box>.Default;

        // Calling Boxes.Sort() with no parameter
        // is the same as calling Boxs.Sort(defComp)
        // because they are both using the default comparer.
        Boxes.Sort();

        foreach (Box bx in Boxes)
        {
            Console.WriteLine("{0}\t{1}\t{2}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString());
        }


        // This explicit interface implementation
        // compares first by the length.
        // Returns -1 because the length of BoxA
        // is less than the length of BoxB.
        BoxLengthFirst LengthFirst = new BoxLengthFirst();

        Comparer<Box> bc = (Comparer<Box>) LengthFirst;

        Box BoxA = new Box(2, 6, 8);
        Box BoxB = new Box(10, 12, 14);
        int x = LengthFirst.Compare(BoxA, BoxB);
        Console.WriteLine();
        Console.WriteLine(x.ToString());
    }
}

public class BoxLengthFirst : Comparer<Box>
{
    // Compares by Length, Height, and Width.
    public override int Compare(Box x, Box y)
    {
        if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }
}

// This class is not demonstrated in the Main method
// and is provided only to show how to implement
// the interface. It is recommended to derive
// from Comparer<T> instead of implementing IComparer<T>.
public class BoxComp : IComparer<Box>
{
    // Compares by Height, Length, and Width.
    public int Compare(Box x, Box y)
    {
        if (x.Height.CompareTo(y.Height) != 0)
        {
            return x.Height.CompareTo(y.Height);
        }
        else if (x.Length.CompareTo(y.Length) != 0)
        {
            return x.Length.CompareTo(y.Length);
        }
        else if (x.Width.CompareTo(y.Width) != 0)
        {
            return x.Width.CompareTo(y.Width);
        }
        else
        {
            return 0;
        }
    }
}

public class Box : IComparable<Box>
{

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

    public int CompareTo(Box other)
    {
        // Compares Height, Length, and Width.
        if (this.Height.CompareTo(other.Height) != 0)
        {
            return this.Height.CompareTo(other.Height);
        }
        else if (this.Length.CompareTo(other.Length) != 0)
        {
            return this.Length.CompareTo(other.Length);
        }
        else if (this.Width.CompareTo(other.Width) != 0)
        {
            return this.Width.CompareTo(other.Width);
        }
        else
        {
            return 0;
        }
    }
}

Dérivez de cette classe pour fournir une implémentation personnalisée de l’interface IComparer<T> à utiliser avec des classes de collection telles que les SortedList<TKey,TValue> classes génériques et SortedDictionary<TKey,TValue> .

La différence entre le dérivation de la classe et l’implémentation Comparer<T> de l’interface System.IComparable est la suivante :

• Pour spécifier la façon dont deux objets doivent être comparés par défaut, implémentez l’interface System.IComparable dans votre classe. Cela garantit que les opérations de tri utilisent le code de comparaison par défaut que vous avez fourni.

• Pour définir un comparateur à utiliser au lieu du comparateur par défaut, dérivez de la Comparer<T> classe . Vous pouvez ensuite utiliser ce comparateur dans les opérations de tri qui prennent un comparateur en tant que paramètre.

L’objet retourné par la Default propriété utilise l’interface System.IComparable<T> générique (IComparable<T> en C#, IComparable(Of T) en Visual Basic) pour comparer deux objets. Si le type T n’implémente pas l’interface System.IComparable<T> générique, la Default propriété retourne un Comparer<T> qui utilise l’interface System.IComparable .

Compare(T, T) et Equals(T, T) peuvent se comporter différemment en termes de respect de la culture et de respect de la casse.

Pour les comparaisons de chaînes, la StringComparer classe est recommandée sur Comparer<String>. Les propriétés de la StringComparer classe retournent des instances prédéfinies qui effectuent des comparaisons de chaînes avec différentes combinaisons de respect de la culture et de respect de la casse. Le respect de la casse et le respect de la culture sont cohérents entre les membres d’un même StringComparer instance.

Pour plus d’informations sur les comparaisons spécifiques à la culture, consultez l’espace System.Globalization de noms et Globalisation et Localisation.

• IComparer<T>
• IComparable<T>
• StringComparer
• CultureInfo