Freigeben über


Tuple<T1,T2>.IStructuralComparable.CompareTo(Object, IComparer) Methode

Definition

Vergleicht das aktuelle Tuple<T1,T2>-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

other ist kein Tuple<T1,T2>-Objekt.

Beispiele

Im folgenden Beispiel wird ein Array von Tuple<T1,T2> Objekten erstellt, die aus dem Namen und der Testbewertung eines Schülers bestehen. Es zeigt die Komponente jedes Tuples im Array in nicht sortierter Reihenfolge an, sortiert das Array und ruft ToString dann auf, um den Wert der einzelnen Tupel in sortierter Reihenfolge anzuzeigen. Um das Array zu sortieren, definiert das Beispiel eine generische ScoreComparer Klasse, die die IComparer Schnittstelle implementiert und die Tuple<T1,T2> Objekte in aufsteigender Reihenfolge nach dem Wert ihrer zweiten Komponente statt ihrer ersten Komponente sortiert. Beachten Sie, dass das Beispiel die IStructuralComparable.CompareTo Methode nicht direkt aufruft. Diese Methode wird implizit durch die Array.Sort(Array, IComparer) Methode für jedes Element im Array aufgerufen.

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

public class ScoreComparer<T1, T2> : IComparer
{
   public int Compare(object x, object y)
   {
      Tuple<T1, T2> tX = x as Tuple<T1,T2>;
      if (tX == null)
      { 
         return 0;
      }   
      else
      {
         Tuple<T1, T2> tY = y as Tuple<T1, T2>;
         return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2);             
      }
   }
}

public class Example
{
   public static void Main()
   {
      Tuple<string, Nullable<int>>[] scores = 
                    { new Tuple<string, Nullable<int>>("Jack", 78),
                      new Tuple<string, Nullable<int>>("Abbey", 92), 
                      new Tuple<string, Nullable<int>>("Dave", 88),
                      new Tuple<string, Nullable<int>>("Sam", 91), 
                      new Tuple<string, Nullable<int>>("Ed", null),
                      new Tuple<string, Nullable<int>>("Penelope", 82),
                      new Tuple<string, Nullable<int>>("Linda", 99),
                      new Tuple<string, Nullable<int>>("Judith", 84) };

      Console.WriteLine("The values in unsorted order:");
      foreach (var score in scores)
         Console.WriteLine(score.ToString());

      Console.WriteLine();

      Array.Sort(scores, new ScoreComparer<string, Nullable<int>>());

      Console.WriteLine("The values in sorted order:");
      foreach (var score in scores)
         Console.WriteLine(score.ToString());
   }
}
// The example displays the following output;
//       The values in unsorted order:
//       (Jack, 78)
//       (Abbey, 92)
//       (Dave, 88)
//       (Sam, 91)
//       (Ed, )
//       (Penelope, 82)
//       (Linda, 99)
//       (Judith, 84)
//       
//       The values in sorted order:
//       (Ed, )
//       (Jack, 78)
//       (Penelope, 82)
//       (Judith, 84)
//       (Dave, 88)
//       (Sam, 91)
//       (Abbey, 92)
//       (Linda, 99)
open System
open System.Collections
open System.Collections.Generic

type ScoreComparer<'T1, 'T2>() =
    interface IComparer with
        member _.Compare(x: obj, y: obj) =
            match x with
            | :? Tuple<'T1, 'T2> as tX ->
                let tY = y :?> Tuple<'T1, 'T2>
                Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2)             
            | _ -> 0

let scores = 
    [| Tuple<string, Nullable<int>>("Jack", 78)
       Tuple<string, Nullable<int>>("Abbey", 92) 
       Tuple<string, Nullable<int>>("Dave", 88)
       Tuple<string, Nullable<int>>("Sam", 91) 
       Tuple<string, Nullable<int>>("Ed", Nullable())
       Tuple<string, Nullable<int>>("Penelope", 82)
       Tuple<string, Nullable<int>>("Linda", 99)
       Tuple<string, Nullable<int>>("Judith", 84) |]

printfn "The values in unsorted order:"
for score in scores do
    printfn $"{score}"

printfn ""

Array.Sort(scores, ScoreComparer<string, Nullable<int>>())

printfn "The values in sorted order:"
for score in scores do
    printfn $"{score}"
// The example displays the following output
//       The values in unsorted order:
//       (Jack, 78)
//       (Abbey, 92)
//       (Dave, 88)
//       (Sam, 91)
//       (Ed, )
//       (Penelope, 82)
//       (Linda, 99)
//       (Judith, 84)
//       
//       The values in sorted order:
//       (Ed, )
//       (Jack, 78)
//       (Penelope, 82)
//       (Judith, 84)
//       (Dave, 88)
//       (Sam, 91)
//       (Abbey, 92)
//       (Linda, 99)
Imports System.Collections
Imports System.Collections.Generic

Public Class ScoreComparer(Of T1, T2) : Implements IComparer
   Public Function Compare(x As Object, y As Object) As Integer _
                   Implements IComparer.Compare
      Dim tX As Tuple(Of T1, T2) = TryCast(x, Tuple(Of T1, T2))
      If tX Is Nothing Then
         Return 0
      Else
         Dim tY As Tuple(Of T1, T2) = DirectCast(y, Tuple(Of T1, T2))
         Return Comparer(Of T2).Default.Compare(tx.Item2, tY.Item2)             
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim scores() As Tuple(Of String, Nullable(Of Integer)) = 
                      { New Tuple(Of String, Nullable(Of Integer))("Jack", 78),
                        New Tuple(Of String, Nullable(Of Integer))("Abbey", 92), 
                        New Tuple(Of String, Nullable(Of Integer))("Dave", 88),
                        New Tuple(Of String, Nullable(Of Integer))("Sam", 91), 
                        New Tuple(Of String, Nullable(Of Integer))("Ed", Nothing),
                        New Tuple(Of String, Nullable(Of Integer))("Penelope", 82),
                        New Tuple(Of String, Nullable(Of Integer))("Linda", 99),
                        New Tuple(Of String, Nullable(Of Integer))("Judith", 84) }

      Console.WriteLine("The values in unsorted order:")
      For Each score In scores
         Console.WriteLine(score.ToString())
      Next
      Console.WriteLine()

      Array.Sort(scores, New ScoreComparer(Of String, Nullable(Of Integer))())

      Console.WriteLine("The values in sorted order:")
      For Each score In scores
         Console.WriteLine(score.ToString())
      Next
   End Sub
End Module
' The example displays the following output;
'       The values in unsorted order:
'       (Jack, 78)
'       (Abbey, 92)
'       (Dave, 88)
'       (Sam, 91)
'       (Ed, )
'       (Penelope, 82)
'       (Linda, 99)
'       (Judith, 84)
'       
'       The values in sorted order:
'       (Ed, )
'       (Jack, 78)
'       (Penelope, 82)
'       (Judith, 84)
'       (Dave, 88)
'       (Sam, 91)
'       (Abbey, 92)
'       (Linda, 99)

Hinweise

Bei diesem Member handelt es sich um eine explizite Schnittstellenmemberimplementierung. Er kann nur verwendet werden, wenn die Tuple<T1,T2>-Instanz in eine IStructuralComparable-Schnittstelle umgewandelt wird.

Obwohl diese Methode direkt aufgerufen werden kann, wird sie am häufigsten von Auflistungssortiermethoden 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