Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo Methode
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.
Vergleicht das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt anhand eines angegebenen Vergleichs mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob sich das aktuelle Element in der Sortierreihenfolge vor dem angegebenen Element, dahinter oder an derselben Position befindet.
virtual int System.Collections.IStructuralComparable.CompareTo(System::Object ^ other, System::Collections::IComparer ^ comparer) = System::Collections::IStructuralComparable::CompareTo;int IStructuralComparable.CompareTo (object other, System.Collections.IComparer comparer);abstract member System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int
override this.System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> intFunction CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareToParameter
- other
- Object
Ein Objekt, das mit der aktuellen Instanz verglichen werden soll.
- comparer
- IComparer
Ein Objekt, das benutzerdefinierte Regeln für Vergleiche bereitstellt.
Gibt zurück
Eine ganze Zahl mit Vorzeichen, die die relative Position dieser Instanz und von other in der Sortierreihenfolge angibt, wie in der folgenden Tabelle veranschaulicht.
| Wert | BESCHREIBUNG |
|---|---|
| Eine negative ganze Zahl | Diese Instanz geht other voran.
|
| Zero | Diese Instanz und other befinden sich in der Sortierreihenfolge an der gleichen Position.
|
| Eine positive ganze Zahl | Diese Instanz folgt other.
|
Implementiert
Ausnahmen
other ist kein Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Objekt.
Beispiele
Im folgenden Beispiel wird ein Array von Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekten erstellt, das Einwohnerdaten für vier US-Städte von 1940 bis 2000 enthält. Die erste Komponente des Oktuples ist der Stadtname. Die restlichen sechs Komponenten stellen die Bevölkerung in Abständen von 10 Jahren von 1940 bis 2000 dar.
Die PopulationComparer -Klasse stellt eine IComparer Implementierung bereit, mit der das Array von Oktuples nach einer ihrer Komponenten sortiert werden kann. Der Klasse in ihrem PopulationComparer Konstruktor werden zwei Werte bereitgestellt: Die Position der Komponente, die die Sortierreihenfolge definiert, und ein Boolean Wert, der angibt, ob die Tupelobjekte in aufsteigender oder absteigender Reihenfolge sortiert werden sollen.
Das Beispiel zeigt dann die Elemente im Array in unsortierter Reihenfolge an, sortiert sie nach der dritten Komponente (die Auffüllung im Jahr 1950) und zeigt sie dann nach der achten Komponente (die Auffüllung im Jahr 2000) und zeigt sie an.
using System;
using System.Collections;
using System.Collections.Generic;
public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7, T8> : IComparer
{
private int itemPosition;
private int multiplier = -1;
public PopulationComparer(int component) : this(component, true)
{ }
public PopulationComparer(int component, bool descending)
{
if (! descending) multiplier = 1;
if (component <= 0 || component > 8)
throw new ArgumentException("The component argument is out of range.");
itemPosition = component;
}
public int Compare(object x, object y)
{
Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
if (tX == null)
return 0;
Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
switch (itemPosition)
{
case 1:
return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
case 2:
return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier;
case 3:
return Comparer<T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier;
case 4:
return Comparer<T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier;
case 5:
return Comparer<T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier;
case 6:
return Comparer<T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier;
case 7:
return Comparer<T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier;
case 8:
return Comparer<T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier;
default:
return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
}
}
}
public class Example
{
public static void Main()
{
// Create array of octuples with population data for three U.S.
// cities, 1940-2000.
Tuple<string, int, int, int, int, int, int, Tuple<int>>[] cities =
{ Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) };
// Display array in unsorted order.
Console.WriteLine("In unsorted order:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int, int>(2));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 1950:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int, int>(8));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 2000:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
}
}
// The example displays the following output:
// In unsorted order:
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//
// Sorted by population in 1950:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 2000:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
open System
open System.Collections
open System.Collections.Generic
type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>(itemPosition, descending) =
let multiplier = if descending then -1 else 1
do
if itemPosition <= 0 || itemPosition > 8 then
invalidArg "itemPosition" "The component argument is out of range."
new(itemPosition) = PopulationComparer (itemPosition, true)
interface IComparer with
member _.Compare(x, y) =
match x with
| :? Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>> as tX ->
let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>>
match itemPosition with
| 1 ->
Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
| 2 ->
Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier
| 3 ->
Comparer<'T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier
| 4 ->
Comparer<'T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier
| 5 ->
Comparer<'T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier
| 6 ->
Comparer<'T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier
| 7 ->
Comparer<'T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier
| 8 ->
Comparer<'T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
| _ ->
Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
| _ -> 0
// Create array of octuples with population data for three U.S.
// cities, 1940-2000.
let cities =
[| Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) |]
// Display array in unsorted order.
printfn "In unsorted order:"
for city in cities do
printfn $"{city}"
printfn ""
Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int> 2)
// Display array in sorted order.
printfn "Sorted by population in 1950:"
for city in cities do
printfn $"{city}"
printfn ""
Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int>(8))
// Display array in sorted order.
printfn "Sorted by population in 2000:"
for city in cities do
printfn $"{city}"
// The example displays the following output:
// In unsorted order:
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//
// Sorted by population in 1950:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 2000:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
Imports System.Collections
Imports System.Collections.Generic
Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7, T8) : Implements IComparer
Private itemPosition As Integer
Private multiplier As Integer = -1
Public Sub New(component As Integer)
Me.New(component, True)
End Sub
Public Sub New(component As Integer, descending As Boolean)
If Not descending Then multiplier = 1
If component <= 0 Or component > 8 Then
Throw New ArgumentException("The component argument is out of range.")
End If
itemPosition = component
End Sub
Public Function Compare(x As Object, y As Object) As Integer _
Implements IComparer.Compare
Dim tX As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
If tX Is Nothing Then
Return 0
Else
Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
Select Case itemPosition
Case 1
Return Comparer(Of T1).Default.Compare(tX.Item1, tY.Item1) * multiplier
Case 2
Return Comparer(Of T2).Default.Compare(tX.Item2, tY.Item2) * multiplier
Case 3
Return Comparer(Of T3).Default.Compare(tX.Item3, tY.Item3) * multiplier
Case 4
Return Comparer(Of T4).Default.Compare(tX.Item4, tY.Item4) * multiplier
Case 5
Return Comparer(Of T5).Default.Compare(tX.Item5, tY.Item5) * multiplier
Case 6
Return Comparer(Of T6).Default.Compare(tX.Item6, tY.Item6) * multiplier
Case 7
Return Comparer(Of T7).Default.Compare(tX.Item7, tY.Item7) * multiplier
Case 8
Return Comparer(Of T8).Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
End Select
End If
End Function
End Class
Module Example
Public Sub Main()
' Create array of octuples with population data for three U.S.
' cities, 1940-2000.
Dim cities() = _
{ Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) }
' Display array in unsorted order.
Console.WriteLine("In unsorted order:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
Console.WriteLine()
Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer, Integer)(2))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 1950:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
Console.WriteLine()
Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer, Integer)(8))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 2000:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
End Sub
End Module
' The example displays the following output:
' In unsorted order:
' (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'
' Sorted by population in 1950:
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
' (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'
' Sorted by population in 2000:
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
Hinweise
Dieser Member ist eine explizite Schnittstellenimplementierung. Er kann nur verwendet werden, wenn die Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>-Instanz in eine IStructuralComparable-Schnittstelle umgewandelt wird.
Mit dieser Methode können Sie benutzerdefinierte Vergleiche von Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> Objekten definieren. Mit dieser Methode können Sie beispielsweise Objekte basierend auf dem Wert einer bestimmten Komponente sortieren Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> .
Obwohl diese Methode direkt aufgerufen werden kann, wird sie am häufigsten von Auflistungssortierungsmethoden aufgerufen, die Parameter enthalten IComparer , um die Member einer Auflistung zu ordnen. Sie wird beispielsweise von der Array.Sort(Array, IComparer) -Methode und der Add -Methode eines SortedList Objekts aufgerufen, das mithilfe des SortedList.SortedList(IComparer) Konstruktors instanziiert wird.
Achtung
Die IStructuralComparable.CompareTo Methode ist für die Verwendung in Sortiervorgängen vorgesehen. Es sollte nicht verwendet werden, wenn der Hauptzweck eines Vergleichs darin besteht, zu bestimmen, ob zwei Objekte gleich sind. Um zu bestimmen, ob zwei Objekte gleich sind, rufen Sie die -Methode auf IStructuralEquatable.Equals .
