Comparer<T> Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine Basisklasse für Implementierungen der generischen IComparer<T>-Schnittstelle bereit.
generic <typename T>
public ref class Comparer abstract : System::Collections::Generic::IComparer<T>, System::Collections::IComparerpublic 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.IComparertype 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)Typparameter
- T
Der Typ der zu vergleichenden Objekte.
- Vererbung
-
Comparer<T>
- Attribute
- Implementiert
Beispiele
Das folgende Beispiel leitet eine Klasse von BoxLengthFirstder Comparer<T> -Klasse ab. Dieser Vergleich vergleicht zwei Objekte vom Typ Box. Sie sortiert sie zuerst nach Länge, dann nach Höhe und dann nach Breite. Die Box -Klasse implementiert die IComparable<T> Schnittstelle, um den Standardvergleich zwischen zwei Box Objekten zu steuern. Diese Standardimplementierung sortiert zuerst nach Höhe, dann nach Länge und dann nach Breite. Das Beispiel zeigt die Unterschiede zwischen den beiden Vergleichen, indem eine Liste von Box Objekten zuerst mithilfe des BoxLengthFirst Vergleichs und dann mithilfe des Standardvergleichs sortiert wird.
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
Hinweise
Leiten Sie von dieser Klasse ab, um eine benutzerdefinierte Implementierung der Schnittstelle für die IComparer<T> Verwendung mit Auflistungsklassen wie den SortedList<TKey,TValue> generischen Klassen und SortedDictionary<TKey,TValue> bereitzustellen.
Der Unterschied zwischen der Ableitung von der Comparer<T> -Klasse und der Implementierung der System.IComparable Schnittstelle ist wie folgt:
Um anzugeben, wie zwei Objekte standardmäßig verglichen werden sollen, implementieren Sie die System.IComparable Schnittstelle in Ihrer Klasse. Dadurch wird sichergestellt, dass Sortiervorgänge den von Ihnen angegebenen Standardvergleichscode verwenden.
Um einen Vergleich zu definieren, der anstelle des Standardvergleichs verwendet werden soll, leiten Sie von der Comparer<T> -Klasse ab. Sie können diesen Vergleich dann in Sortiervorgängen verwenden, bei denen ein Comparer als Parameter verwendet wird.
Das von der Default -Eigenschaft zurückgegebene Objekt verwendet die System.IComparable<T> generische Schnittstelle (IComparable<T> in C#, IComparable(Of T) in Visual Basic), um zwei Objekte zu vergleichen. Wenn type T die System.IComparable<T> generische Schnittstelle nicht implementiert, gibt die Default Eigenschaft eine Comparer<T> zurück, die die System.IComparable Schnittstelle verwendet.
Hinweise für Ausführende
Compare(T, T) und Equals(T, T) verhalten sich möglicherweise in Bezug auf Kultursensitivität und Groß-/Kleinschreibung unterschiedlich.
Für Zeichenfolgenvergleiche wird die StringComparer -Klasse über Comparer<String>empfohlen. Eigenschaften der StringComparer -Klasse geben vordefinierte Instanzen zurück, die Zeichenfolgenvergleiche mit unterschiedlichen Kombinationen von Kultursensitivität und Groß-/Kleinschreibung durchführen. Die Groß-/Kleinschreibung und die Kultursensitivität sind bei den Mitgliedern derselben StringComparer instance konsistent.
Weitere Informationen zu kulturspezifischen Vergleichen finden Sie unter Namespace System.Globalization und Globalisierung und Lokalisierung.
Konstruktoren
| Comparer<T>() |
Initialisiert eine neue Instanz der Comparer<T>-Klasse. |
Eigenschaften
| Default |
Gibt für den vom generischen Argument angegebenen Typ einen Standardvergleich für die Sortierreihenfolgen zurück. |
Methoden
| Compare(T, T) |
Vergleicht beim Überschreiben in einer abgeleiteten Klasse zwei Objekte gleichen Typs und gibt über den zurückgegebenen Wert an, ob das eine Objekt kleiner, größer oder gleich dem anderen Objekt ist. |
| Create(Comparison<T>) |
Erstellt mithilfe des angegebenen Vergleichs einen Vergleich. |
| Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
| GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |
Explizite Schnittstellenimplementierungen
| IComparer.Compare(Object, Object) |
Vergleicht zwei Objekte und gibt einen Wert zurück, der angibt, ob ein Wert niedriger, gleich oder größer als der andere Wert ist. |
Gilt für:
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für