Freigeben über


Tuple<T1,T2,T3,T4,T5,T6,T7>.IStructuralComparable.CompareTo Methode

Definition

Vergleicht das aktuelle Tuple<T1,T2,T3,T4,T5,T6,T7>-Objekt anhand eines angegebenen Vergleichs mit einem angegebenen Objekt und gibt eine ganze Zahl zurück, die angibt, ob sich das aktuelle Objekt in der Sortierreihenfolge vor dem angegebenen Objekt, 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 -> int
Function CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareTo

Parameter

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

Int32

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

Beispiele

Im folgenden Beispiel wird ein Array von Tuple<T1,T2,T3,T4,T5,T6,T7> Objekten erstellt, das Bevölkerungsdaten für drei US-Städte von 1950 bis 2000 enthält. Die erste Komponente des Septuples ist der Name der Stadt. Die verbleibenden fünf Komponenten stellen die Bevölkerung mit 10-Jahresintervallen von 1950 bis 2000 dar.

Die PopulationComparer Klasse bietet eine IComparer Implementierung, mit der das Array von Septuples sortiert werden kann. Zwei Werte werden der Klasse in seinem Konstruktor bereitgestellt PopulationComparer : Die Position der Komponente, die die Sortierreihenfolge definiert, und ein Boolean Wert, der angibt, ob die Tupleobjekte in aufsteigender oder absteigender Reihenfolge sortiert werden sollen.

Das Beispiel zeigt dann die Elemente im Array in nicht sortierter Reihenfolge an, sortiert sie nach der dritten Komponente (der Bevölkerung im Jahr 1960) und zeigt sie an, und sortiert sie dann nach der sechsten Komponente (der Bevölkerung im Jahr 1990) und zeigt sie an.

using System;
using System.Collections;
using System.Collections.Generic;

public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7> : 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 > 7)
         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> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7>;
      if (tX == null)
      {
         return 0;
      }
      else
      {
         Tuple<T1, T2, T3, T4, T5, T6, T7> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7>;
         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;
            default:
               return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
         }
      }
   }
}

public class Example
{
   public static void Main()
   {
      // Create array of sextuple with population data for three U.S.
      // cities, 1960-2000.
      Tuple<string, int, int, int, int, int, int>[] cities =
           { Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
             Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
             Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) };

      // 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>(3));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1960:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();

      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int>(6));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1990:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
   }
}
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    Sorted by population in 1960:
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 1990:
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
open System
open System.Collections
open System.Collections.Generic

type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>(itemPosition, descending) =
    let multiplier = if descending then -1 else 1

    do
        if itemPosition <= 0 || itemPosition > 7 then
            invalidArg "itemPosition" "The itemPosition 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> as tX -> 
                let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>
                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
                | _ ->
                    Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
            | _ -> 0

// Create array of sextuple with population data for three U.S.
// cities, 1960-2000.
let cities =
    [| Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
       Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
       Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) |]

// 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> 3)

// Display array in sorted order.
printfn "Sorted by population in 1960:"
for city in cities do
    printfn $"{city}"
printfn ""

Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int> 6)

// Display array in sorted order.
printfn "Sorted by population in 1990:"
for city in cities do
    printfn $"{city}"
// The example displays the following output ->
//    In unsorted order ->
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    Sorted by population in 1960 ->
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 1990 ->
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
Imports System.Collections
Imports System.Collections.Generic

Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7) : 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 > 7 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) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7))
      If tX Is Nothing Then
         Return 0
      Else
         Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7))
         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
            ' This should never be reached.
            Case Else
               Return 0
         End Select      
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      ' Create array of sextuple with population data for three U.S. 
      ' cities, 1950-2000.
      Dim cities() = 
          { Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) } 
      
      ' 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)(3)) 
                           
      ' Display array in sorted order.
      Console.WriteLine("Sorted by population in 1960:")
      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)(6))
                           
      ' Display array in sorted order.
      Console.WriteLine("Sorted by population in 1990:")
      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, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    
'    Sorted by population in 1960:
'    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    
'    Sorted by population in 1990:
'    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)

Hinweise

Dieser Member ist eine explizite Schnittstellenimplementierung. Er kann nur verwendet werden, wenn die Tuple<T1,T2,T3,T4,T5,T6,T7>-Instanz in eine IStructuralComparable-Schnittstelle umgewandelt wird.

Mit dieser Methode können Sie benutzerdefinierte Vergleiche von Tuple<T1,T2,T3,T4,T5,T6,T7> Objekten definieren. Sie können beispielsweise diese Methode verwenden, um Objekte basierend auf dem Wert einer bestimmten Komponente zu ordnen Tuple<T1,T2,T3,T4,T5,T6,T7> .

Obwohl diese Methode direkt aufgerufen werden kann, wird sie am häufigsten durch Auflistungssortierungsmethoden aufgerufen, die Parameter enthalten IComparer , um die Elemente einer Auflistung zu bestellen. Sie wird beispielsweise durch die Methode und die Array.Sort(Array, IComparer) 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 primäre Zweck eines Vergleichs besteht, um zu bestimmen, ob zwei Objekte gleich sind. Um zu ermitteln, ob zwei Objekte gleich sind, rufen Sie die IStructuralEquatable.Equals Methode auf.

Gilt für

Siehe auch