Comparer<T> Sınıf

Tanım

Genel arabirimin uygulamaları IComparer<T> için bir temel sınıf sağlar.

generic <typename T>
public ref class Comparer abstract : System::Collections::Generic::IComparer<T>, System::Collections::IComparer
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
type Comparer<'T> = class
    interface IComparer<'T>
    interface IComparer
[<System.Serializable>]
type Comparer<'T> = class
    interface IComparer
    interface IComparer<'T>
Public MustInherit Class Comparer(Of T)
Implements IComparer, IComparer(Of T)

Tür Parametreleri

T

Karşılaştıracak nesne türü.

Devralma
Comparer<T>
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek sınıfından BoxLengthFirst, sınıfını türetir Comparer<T> . Bu karşılaştırıcı türü Boxiki nesneyi karşılaştırır. Bunları önce uzunluğa, sonra yüksekliğe ve sonra genişliğe göre sıralar. sınıfı, Box iki Box nesne arasındaki varsayılan karşılaştırmayı denetlemek için arabirimini uygularIComparable<T>. Bu varsayılan uygulama önce yüksekliğe, sonra uzunluğa ve sonra genişliğe göre sıralar. Örnek, önce karşılaştırıcıyı ve ardından varsayılan karşılaştırıcıyı kullanarak BoxLengthFirst bir nesne listesini Box sıralayarak iki karşılaştırma arasındaki farkları gösterir.

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;
        }
    }
}
Imports System.Collections.Generic

Friend Class Program
    Shared Sub Main(ByVal args() As String)
        Dim Boxes As New List(Of 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("==========")
        For Each bx As Box In Boxes
            Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}", _
                              bx.Height.ToString(), bx.Length.ToString(), _
                              bx.Width.ToString())
        Next bx

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

        ' Get the default comparer that 
        ' sorts first by the height.
        Dim defComp As Comparer(Of Box) = Comparer(Of 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()

        For Each bx As Box In Boxes
            Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}", _
                              bx.Height.ToString(), _
                              bx.Length.ToString(), _
                              bx.Width.ToString())
        Next bx


        ' This explicit interface implementation
        ' compares first by the length.
        ' Returns -1 because the length of BoxA
        ' is less than the length of BoxB.
        Dim LengthFirst As New BoxLengthFirst()

        Dim bc As Comparer(Of Box) = CType(LengthFirst, Comparer(Of Box))

        Dim BoxA As New Box(2, 6, 8)
        Dim BoxB As New Box(10, 12, 14)
        Dim x As Integer = LengthFirst.Compare(BoxA, BoxB)
        Console.WriteLine()
        Console.WriteLine(x.ToString())



    End Sub

End Class

Public Class BoxLengthFirst
    Inherits Comparer(Of Box)
    ' Compares by Length, Height, and Width.
    Public Overrides Function Compare(ByVal x As Box, ByVal y As Box) As Integer
        If x.Length.CompareTo(y.Length) <> 0 Then
            Return x.Length.CompareTo(y.Length)
        ElseIf x.Height.CompareTo(y.Height) <> 0 Then
            Return x.Height.CompareTo(y.Height)
        ElseIf x.Width.CompareTo(y.Width) <> 0 Then
            Return x.Width.CompareTo(y.Width)
        Else
            Return 0
        End If
    End Function

End Class

' 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
    Implements IComparer(Of Box)
    ' Compares by Height, Length, and Width.
    Public Function Compare(ByVal x As Box, ByVal y As Box) As Integer Implements _
                                                IComparer(Of Box).Compare
        If x.Height.CompareTo(y.Height) <> 0 Then
            Return x.Height.CompareTo(y.Height)
        ElseIf x.Length.CompareTo(y.Length) <> 0 Then
            Return x.Length.CompareTo(y.Length)
        ElseIf x.Width.CompareTo(y.Width) <> 0 Then
            Return x.Width.CompareTo(y.Width)
        Else
            Return 0
        End If
    End Function
End Class

Public Class Box
    Implements IComparable(Of Box)

    Public Sub New(ByVal h As Integer, ByVal l As Integer, ByVal w As Integer)
        Me.Height = h
        Me.Length = l
        Me.Width = w
    End Sub
    Private privateHeight As Integer
    Public Property Height() As Integer
        Get
            Return privateHeight
        End Get
        Private Set(ByVal value As Integer)
            privateHeight = value
        End Set
    End Property
    Private privateLength As Integer
    Public Property Length() As Integer
        Get
            Return privateLength
        End Get
        Private Set(ByVal value As Integer)
            privateLength = value
        End Set
    End Property
    Private privateWidth As Integer
    Public Property Width() As Integer
        Get
            Return privateWidth
        End Get
        Private Set(ByVal value As Integer)
            privateWidth = value
        End Set
    End Property

    Public Function CompareTo(ByVal other As Box) As Integer _
                        Implements IComparable(Of Box).CompareTo
        ' Compares Height, Length, and Width.
        If Me.Height.CompareTo(other.Height) <> 0 Then
            Return Me.Height.CompareTo(other.Height)
        ElseIf Me.Length.CompareTo(other.Length) <> 0 Then
            Return Me.Length.CompareTo(other.Length)
        ElseIf Me.Width.CompareTo(other.Width) <> 0 Then
            Return Me.Width.CompareTo(other.Width)
        Else
            Return 0
        End If
    End Function

End Class

Açıklamalar

ve SortedDictionary<TKey,TValue> genel sınıfları gibi koleksiyon sınıflarıyla kullanılmak üzere arabirimin IComparer<T> özel bir uygulamasını sağlamak için bu sınıftan SortedList<TKey,TValue> türetin.

sınıfından Comparer<T> türetme ile arabirimi uygulama System.IComparable arasındaki fark aşağıdaki gibidir:

  • İki nesnenin varsayılan olarak nasıl karşılaştırılacağını belirtmek için sınıfınızda arabirimini uygulayın System.IComparable . Bu, sıralama işlemlerinin sağladığınız varsayılan karşılaştırma kodunu kullanmasını sağlar.

  • Varsayılan karşılaştırıcı yerine kullanılacak bir karşılaştırıcı tanımlamak için sınıfından türetin Comparer<T> . Ardından bu karşılaştırıcıyı parametre olarak karşılaştırıcı alan sıralama işlemlerinde kullanabilirsiniz.

özelliği tarafından Default döndürülen nesne, iki nesneyi karşılaştırmak için genel arabirimini (IComparable<T>C# dilinde, IComparable(Of T) Visual Basic) kullanırSystem.IComparable<T>. Tür T genel arabirimi uygulamazsaSystem.IComparable<T>, Default özelliği arabirimini kullanan System.IComparable bir Comparer<T> döndürür.

Uygulayanlara Notlar

Compare(T, T) kültüre Equals(T, T) duyarlılık ve büyük/küçük harf duyarlılığı açısından farklı davranabilir.

Dize karşılaştırmaları için, StringComparer sınıfı ComparerString<> üzerinden önerilir. StringComparer sınıfının özellikleri, kültür duyarlılığı ve büyük/küçük harf duyarlılığının farklı bileşimleriyle dize karşılaştırmaları gerçekleştiren önceden tanımlanmış örnekler döndürür. Büyük/küçük harf duyarlılığı ve kültür duyarlılığı aynı StringComparer örneğin üyeleri arasında tutarlıdır.

Kültüre özgü karşılaştırmalar hakkında daha fazla bilgi için ad alanına ve Genelleştirme ve Yerelleştirme'ye bakınSystem.Globalization.

Oluşturucular

Comparer<T>()

Comparer<T> sınıfının yeni bir örneğini başlatır.

Özellikler

Default

Genel bağımsız değişken tarafından belirtilen tür için varsayılan sıralama düzeni karşılaştırıcısını döndürür.

Yöntemler

Compare(T, T)

Türetilmiş bir sınıfta geçersiz kılındığında, aynı türdeki iki nesnenin karşılaştırmasını yapar ve bir nesnenin diğerinden küçük, ona eşit veya ondan büyük olup olmadığını belirten bir değer döndürür.

Create(Comparison<T>)

Belirtilen karşılaştırmayı kullanarak bir karşılaştırıcı oluşturur.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.

(Devralındığı yer: Object)
GetHashCode()

Varsayılan karma işlevi işlevi görür.

(Devralındığı yer: Object)
GetType()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.

(Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

IComparer.Compare(Object, Object)

İki nesneyi karşılaştırır ve birinin diğerinden küçük, ona eşit veya ondan büyük olup olmadığını belirten bir değer döndürür.

Şunlara uygulanır

Ayrıca bkz.