Przeczytaj w języku angielskim

Udostępnij za pośrednictwem


Comparer<T> Klasa

Definicja

Udostępnia klasę bazową dla implementacji interfejsu IComparer<T> ogólnego.

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

Parametry typu

T

Typ obiektów do porównania.

Dziedziczenie
Comparer<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład wyprowadza klasę , BoxLengthFirstz Comparer<T> klasy . Ten porównujący porównuje dwa obiekty typu Box. Posortuje je najpierw według długości, a następnie według wysokości, a następnie według szerokości. Klasa Box implementuje IComparable<T> interfejs do kontrolowania domyślnego porównania między dwoma Box obiektami. Ta domyślna implementacja sortuje najpierw według wysokości, a następnie według długości, a następnie według szerokości. W przykładzie pokazano różnice między dwoma porównaniami, sortując najpierw listę Box obiektów przy użyciu BoxLengthFirst porównywarki, a następnie używając domyślnego porównywarki.

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

Uwagi

Pochodzi z tej klasy, aby zapewnić niestandardową implementację interfejsu IComparer<T> do użycia z klasami kolekcji, takimi jak SortedList<TKey,TValue> klasy ogólne i SortedDictionary<TKey,TValue> .

Różnica między wyprowadzaniem z klasy i implementowaniem interfejsu Comparer<T>System.IComparable jest następująca:

  • Aby określić, jak domyślnie mają być porównywane dwa obiekty, zaimplementuj System.IComparable interfejs w klasie. Dzięki temu operacje sortowania będą używać domyślnego kodu porównania, który został podany.

  • Aby zdefiniować moduł porównujący do użycia zamiast domyślnego modułu Comparer<T> porównywania, pochodzi z klasy . Następnie możesz użyć tego porównania w operacjach sortowania, które przyjmują porównanie jako parametr.

Obiekt zwrócony przez właściwość używa interfejsu DefaultSystem.IComparable<T> ogólnego (IComparable<T> w języku C#, IComparable(Of T) w Visual Basic) do porównania dwóch obiektów. Jeśli typ T nie implementuje interfejsu System.IComparable<T> ogólnego, Default właściwość zwraca Comparer<T> właściwość , która używa interfejsu System.IComparable .

Uwagi dotyczące implementowania

Compare(T, T) i Equals(T, T) może zachowywać się inaczej pod względem poufności kultury i poufności liter.

W przypadku porównań ciągów klasa jest zalecana przez Comparer<String>metodę StringComparer . StringComparer Właściwości klasy zwracają wstępnie zdefiniowane wystąpienia, które wykonują porównania ciągów z różnymi kombinacjami poufności kultury i poufności liter. Wrażliwość wielkości liter i wrażliwość kulturowa są spójne wśród elementów członkowskich tego samego StringComparer wystąpienia.

Aby uzyskać więcej informacji na temat porównań specyficznych dla kultury, zobacz System.Globalization przestrzeń nazw i globalizację i lokalizację.

Konstruktory

Comparer<T>()

Inicjuje nowe wystąpienie klasy Comparer<T>.

Właściwości

Default

Zwraca domyślny porównujący kolejność sortowania dla typu określonego przez argument ogólny.

Metody

Compare(T, T)

W przypadku zastąpienia w klasie pochodnej wykonuje porównanie dwóch obiektów tego samego typu i zwraca wartość wskazującą, czy jeden obiekt jest mniejszy niż, równy lub większy niż drugi.

Create(Comparison<T>)

Tworzy porównanie przy użyciu określonego porównania.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

IComparer.Compare(Object, Object)

Porównuje dwa obiekty i zwraca wartość wskazującą, czy jedna jest mniejsza, równa, czy większa niż druga.

Dotyczy

Zobacz też