Comparer<T> 클래스

정의

IComparer<T> 제네릭 인터페이스의 구현에 대한 기본 클래스를 제공합니다.Provides a base class for implementations of the IComparer<T> generic interface.

generic <typename T>
public ref class Comparer abstract : 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
    interface IComparer<'T>
Public MustInherit Class Comparer(Of T)
Implements IComparer, IComparer(Of T)

형식 매개 변수

T

비교할 개체의 형식입니다.The type of objects to compare.

상속
Comparer<T>
특성
구현

예제

다음 예제에서는 Comparer<T> 클래스에서 BoxLengthFirst클래스를 파생 시킵니다.The following example derives a class, BoxLengthFirst, from the Comparer<T> class. 이 비교자는 Box형식의 두 개체를 비교 합니다.This comparer compares two objects of type Box. 정렬 하 먼저 길이의 높이 너비입니다.It sorts them first by length, then by height, and then by width. Box 클래스는 IComparable<T> 인터페이스를 구현 하 여 두 Box 개체 간의 기본 비교를 제어 합니다.The Box class implements the IComparable<T> interface to control the default comparison between two Box objects. 이 기본 구현은 높이에서 길이 너비에 의해 먼저 정렬합니다.This default implementation sorts first by height, then by length, and then by width. 이 예제에서는 먼저 BoxLengthFirst 비교자를 사용 하 여 Box 개체 목록을 정렬 한 다음 기본 비교자를 사용 하 여 두 비교 간의 차이점을 보여 줍니다.The example shows the differences between the two comparisons by sorting a list of Box objects first by using the BoxLengthFirst comparer and then by using the default comparer.

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

설명

SortedList<TKey,TValue>SortedDictionary<TKey,TValue> 제네릭 클래스와 같은 컬렉션 클래스와 함께 사용할 IComparer<T> 인터페이스의 사용자 지정 구현을 제공 하려면이 클래스에서 파생 합니다.Derive from this class to provide a custom implementation of the IComparer<T> interface for use with collection classes such as the SortedList<TKey,TValue> and SortedDictionary<TKey,TValue> generic classes.

Comparer<T> 클래스에서 파생 되 고 System.IComparable 인터페이스를 구현 하는 경우의 차이점은 다음과 같습니다.The difference between deriving from the Comparer<T> class and implementing the System.IComparable interface is as follows:

  • 기본적으로 두 개체를 비교 하는 방법을 지정 하려면 클래스에서 System.IComparable 인터페이스를 구현 합니다.To specify how two objects should be compared by default, implement the System.IComparable interface in your class. 이렇게 하면 정렬 작업이 제공한 기본 비교 코드를 사용 합니다.This ensures that sort operations will use the default comparison code that you provided.

  • 기본 비교자 대신 사용할 비교자를 정의 하려면 Comparer<T> 클래스에서 파생 합니다.To define a comparer to use instead of the default comparer, derive from the Comparer<T> class. 다음 매개 변수로 비교자를 사용 하는 정렬 작업에서이 비교자를 사용할 수 있습니다.You can then use this comparer in sort operations that take a comparer as a parameter.

Default 속성에서 반환 되는 개체는 System.IComparable<T> 제네릭 인터페이스 (의 C#IComparable<T>, Visual Basic의 IComparable(Of T))를 사용 하 여 두 개체를 비교 합니다.The object returned by the Default property uses the System.IComparable<T> generic interface (IComparable<T> in C#, IComparable(Of T) in Visual Basic) to compare two objects. 형식 T에서 System.IComparable<T> 제네릭 인터페이스를 구현 하지 않는 경우 Default 속성은 System.IComparable 인터페이스를 사용 하는 Comparer<T>을 반환 합니다.If type T does not implement the System.IComparable<T> generic interface, the Default property returns a Comparer<T> that uses the System.IComparable interface.

구현자 참고

Compare(T, T)System.Collections.Generic.EqualityComparer`1.Equals(\`0,\`0)는 문화권 구분 및 대/소문자 구분 측면에서 다르게 동작할 수 있습니다. System.Collections.Generic.Comparer`1.Compare(`0,\`0) and System.Collections.Generic.EqualityComparer`1.Equals(`0,\`0) may behave differently in terms of culture-sensitivity and case-sensitivity. 문자열 비교의 경우 StringComparer 클래스는 비교자<문자열>에 대해 권장 됩니다.For string comparisons, the StringComparer class is recommended over Comparer<String>. StringComparer 클래스의 속성은 문화권 구분 및 대/소문자 구분의 서로 다른 조합을 사용 하 여 문자열 비교를 수행 하는 미리 정의 된 인스턴스를 반환 합니다.Properties of the StringComparer class return predefined instances that perform string comparisons with different combinations of culture-sensitivity and case-sensitivity. 대/소문자 구분 및 문화권 구분은 동일한 StringComparer 인스턴스의 멤버 간에 일치 합니다.The case-sensitivity and culture-sensitivity are consistent among the members of the same StringComparer instance. 문화권 관련 비교에 대 한 자세한 내용은 System.Globalization 네임 스페이스 및 [세계화 및 지역화](~/docs/standard/globalization-localization/index.md)를 참조 하세요.For more information on culture-specific comparisons, see the System.Globalization namespace and [Globalization and Localization](~/docs/standard/globalization-localization/index.md).

생성자

Comparer<T>()

Comparer<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Comparer<T> class.

속성

Default

기본을 반환 합니다. 정렬 순서 비교자 제네릭 인수에서 지정 된 형식에 대 한 합니다.Returns a default sort order comparer for the type specified by the generic argument.

메서드

Compare(T, T)

파생된 클래스에서 재정의 되 면 같은 형식의 두 개체의 비교를 수행 하 고 한 개체가 보다 작은지, 같은지 또는 다른 지를 나타내는 값을 반환 합니다.When overridden in a derived class, performs a comparison of two objects of the same type and returns a value indicating whether one object is less than, equal to, or greater than the other.

Create(Comparison<T>)

지정 된 비교를 사용 하 여 비교자를 만듭니다.Creates a comparer by using the specified comparison.

Equals(Object)

지정한 개체가 현재 개체와 같은지를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

현재 개체를 나타내는 string을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)

명시적 인터페이스 구현

IComparer.Compare(Object, Object)

두 개체를 비교하여 한 개체가 다른 개체보다 작거나, 같거나 또는 크다는 것을 나타내는 값을 반환합니다.Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.

적용 대상

추가 정보