Comparer<T> 类

定义

命名空间:

System.Collections.Generic

程序集:

System.Collections.dll

程序集:

mscorlib.dll

程序集:

netstandard.dll

为 IComparer<T> 泛型接口的实现提供基类。

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

要比较的对象的类型。

继承

Object

Comparer<T>

属性

SerializableAttribute

实现

IComparer<T> IComparer

示例

以下示例从Comparer<T>类BoxLengthFirst派生类。 此比较器比较类型 Box为两个对象。 它首先按长度、高度和宽度对它们进行排序。 该 Box 类实现 IComparable<T> 接口来控制两个 Box 对象之间的默认比较。 此默认实现先按高度排序，再按长度排序，然后按宽度排序。 该示例通过先使用BoxLengthFirst比较器对对象列表Box进行排序，然后使用默认比较器来显示这两个比较之间的差异。

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>。

从 Comparer<T> 类派生和实现 System.IComparable 接口之间的区别如下：

• 若要指定默认情况下应如何比较两个对象，请在类中实现 System.IComparable 接口。 这可确保排序操作将使用你提供的默认比较代码。

• 若要定义要使用的比较器而不是默认比较器，请派生自 Comparer<T> 类。 然后，可以在将比较器作为参数的排序操作中使用此比较器。

属性返回Default的对象使用 System.IComparable<T> C# 中的泛型接口 (IComparable<T>， IComparable(Of T) Visual Basic) 比较两个对象。 如果类型T不实现System.IComparable<T>泛型接口，则Default属性返回使用该接口的System.IComparable接口Comparer<T>。

实施者说明

Compare(T, T) 在 Equals(T, T) 区域性敏感度和区分大小写方面的行为可能有所不同。

对于字符串比较，StringComparer建议对 CompareerString<> 使用类。 StringComparer类的属性返回预定义实例，这些实例使用区域性敏感度和区分大小写的不同组合执行字符串比较。 区分大小写和区域性敏感度在同一 StringComparer 实例的成员之间保持一致。

有关特定于区域性的比较的详细信息，请参阅 System.Globalization 命名空间 和全球化和本地化。

构造函数

Comparer<T>()

初始化 Comparer<T> 类的新实例。

属性

Default

返回由泛型参数指定的类型的默认排序顺序比较器。

方法

Compare(T, T)	在派生类中重写时，对同一类型的两个对象执行比较并返回一个值，指示一个对象是小于、等于还是大于另一个对象。
Create(Comparison<T>)	用指定的比较创建一个比较器。
Equals(Object)	确定指定对象是否等于当前对象。 (继承自 Object)
GetHashCode()	作为默认哈希函数。 (继承自 Object)
GetType()	获取当前实例的 Type。 (继承自 Object)
MemberwiseClone()	创建当前 Object 的浅表副本。 (继承自 Object)
ToString()	返回表示当前对象的字符串。 (继承自 Object)

显式接口实现

IComparer.Compare(Object, Object)

比较两个对象并返回一个值，该值指示一个对象小于、等于还是大于另一个对象。

另请参阅

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