Freigeben über


Tuple<T1>.IComparable.CompareTo(Object) Methode

Definition

Vergleicht das aktuelle Tuple<T1>-Objekt 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.IComparable.CompareTo(System::Object ^ obj) = IComparable::CompareTo;
int IComparable.CompareTo (object obj);
abstract member System.IComparable.CompareTo : obj -> int
override this.System.IComparable.CompareTo : obj -> int
Function CompareTo (obj As Object) As Integer Implements IComparable.CompareTo

Parameter

obj
Object

Ein Objekt, das mit der aktuellen Instanz verglichen werden soll.

Gibt zurück

Int32

Eine ganze Zahl mit Vorzeichen, die die relative Position dieser Instanz und von obj in der Sortierreihenfolge angibt, wie in der folgenden Tabelle veranschaulicht.

Wert BESCHREIBUNG
Eine negative ganze Zahl Diese Instanz geht obj voran.
Zero Diese Instanz und obj befinden sich in der Sortierreihenfolge an der gleichen Position.
Eine positive ganze Zahl Diese Instanz folgt obj.

Implementiert

Ausnahmen

obj ist kein Tuple<T1>-Objekt.

Beispiele

Im folgenden Beispiel wird ein Array von Singletons erstellt, deren Komponente ein Double Wert ist. Es zeigt den Wert jeder Tupelkomponente in nicht sortierter Reihenfolge an, sortiert das Array und zeigt dann die Werte in sortierter Reihenfolge an. Beachten Sie, dass das Beispiel die Tuple<T1>.IComparable.CompareTo Methode nicht direkt aufruft. Diese Methode wird implizit von der Sort(Array) Methode für jedes Element im Array aufgerufen.

using System;

class Example
{
   static void Main()
   {
      Tuple<Double>[] values = { Tuple.Create(13.54),
                                 Tuple.Create(Double.NaN),
                                 Tuple.Create(-189.42993),
                                 Tuple.Create(Double.PositiveInfinity),
                                 Tuple.Create(Double.Epsilon),
                                 Tuple.Create(1.934E-17),
                                 Tuple.Create(Double.NegativeInfinity),
                                 Tuple.Create(-0.000000000003588),
                                 null };
      Console.WriteLine("The values in unsorted order:");
      foreach (var value in values)
         if (value != null)
            Console.WriteLine("   {0}", value.Item1);
         else
            Console.WriteLine("   <null>");
      Console.WriteLine();

      Array.Sort(values);

      Console.WriteLine("The values in sorted order:");
      foreach (var value in values)
         if (value != null)
            Console.WriteLine("   {0}", value.Item1);
         else
            Console.WriteLine("   <null>");
   }
}
// The example displays the following output:
//      The values in unsorted order:
//         13.54
//         NaN
//         -189.42993
//         Infinity
//         4.94065645841247E-324
//         1.934E-17
//         -Infinity
//         -3.588E-12
//
//      The values in sorted order:
//         NaN
//         -Infinity
//         -189.42993
//         -3.588E-12
//         4.94065645841247E-324
//         1.934E-17
//         13.54
//         Infinity
open System

let values = 
    [| Tuple.Create 13.54
       Tuple.Create Double.NaN
       Tuple.Create -189.42993
       Tuple.Create Double.PositiveInfinity
       Tuple.Create Double.Epsilon
       Tuple.Create 1.934E-17
       Tuple.Create Double.NegativeInfinity
       Tuple.Create -0.000000000003588
       null |]
printfn "The values in unsorted order:"
for value in values do
    printfn $"   %A{value.Item1}"
printfn ""

Array.Sort values

printfn "The values sorted in descending order:"
for value in values do
    printfn $"   %A{value.Item1}"
// The example displays the following output:
//      The values in unsorted order:
//         13.54
//         NaN
//         -189.42993
//         Infinity
//         4.94065645841247E-324
//         1.934E-17
//         -Infinity
//         -3.588E-12
//
//      The values in sorted order:
//         NaN
//         -Infinity
//         -189.42993
//         -3.588E-12
//         4.94065645841247E-324
//         1.934E-17
//         13.54
//         Infinity
Module Example
    Sub Main()
        Dim values() = { Tuple.Create(13.54),
                         Tuple.Create(Double.NaN),
                         Tuple.Create(-189.42993),
                         Tuple.Create(Double.PositiveInfinity),
                         Tuple.Create(Double.Epsilon),
                         Tuple.Create(1.934E-17),
                         Tuple.Create(Double.NegativeInfinity),
                         Tuple.Create(-0.000000000003588),
                         Nothing}

        Console.WriteLine("The values in unsorted order:")
        For Each value In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
        Console.WriteLine()

        Array.Sort(values)

        Console.WriteLine("The values in sorted order:")
        For Each value In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'      The values in unsorted order:
'         13.54
'         NaN
'         -189.42993
'         Infinity
'         4.94065645841247E-324
'         1.934E-17
'         -Infinity
'         -3.588E-12
'
'      The values in sorted order:
'         NaN
'         -Infinity
'         -189.42993
'         -3.588E-12
'         4.94065645841247E-324
'         1.934E-17
'         13.54
'         Infinity

Hinweise

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

Diese Methode stellt die IComparable.CompareTo Implementierung für die Tuple<T1> Klasse bereit. Obwohl die Methode direkt aufgerufen werden kann, wird sie am häufigsten von den Standardüberladungen der Sortiermethoden der Auflistung aufgerufen, z Array.Sort(Array) . B. und SortedList.Add, um die Elemente einer Auflistung zu bestellen.

Achtung

Die Tuple<T1>.IComparable.CompareTo Methode ist für die Verwendung in Sortiervorgängen vorgesehen. Es sollte nicht verwendet werden, wenn der hauptzweck eines Vergleichs besteht, um zu bestimmen, ob zwei Objekte gleich sind. Rufen Sie die Equals Methode auf, um zu bestimmen, ob zwei Objekte gleich sind.

Die Tuple<T1>.IComparable.CompareTo Methode verwendet den Standardobjektvergleich.

Gilt für

Siehe auch