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

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

Tuple.cs

Confronta l'oggetto Tuple<T1> corrente con un oggetto specificato e restituisce un Integer che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato all'interno dell'ordinamento.

 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

Parametri

obj

Object

Oggetto da confrontare con l'istanza corrente.

Restituisce

Int32

Intero con segno che indica la posizione relativa di questa istanza e di obj nell'ordinamento, come illustrato nella tabella seguente.

Valore	Descrizione
Intero negativo	Questa istanza precede obj.
Zero	Questa istanza si trova nella stessa posizione di obj nell'ordinamento.
Intero positivo	L'istanza segue obj.

Implementazioni

CompareTo(Object)

Eccezioni

ArgumentException

obj non è un oggetto Tuple<T1>.

Esempio

Nell'esempio seguente viene creata una matrice di singleton il cui componente è un Double valore. Visualizza il valore di ogni componente tupla in ordine non ordinato, ordina la matrice e quindi visualizza i valori in ordine ordinato. Si noti che l'esempio non chiama direttamente il Tuple<T1>.IComparable.CompareTo metodo. Questo metodo viene chiamato in modo implicito dal Sort(Array) metodo per ogni elemento della matrice.

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

Commenti

Questo membro è un’implementazione esplicita di un membro di interfaccia. Può essere utilizzato solo quando si esegue il cast dell'istanza Tuple<T1> a un'interfaccia IComparable.

Questo metodo fornisce l'implementazione IComparable.CompareTo per la Tuple<T1> classe. Anche se il metodo può essere chiamato direttamente, è più comunemente chiamato dagli overload predefiniti dei metodi di ordinamento della raccolta, ad esempio Array.Sort(Array) e SortedList.Add, per ordinare i membri di una raccolta.

Attenzione

Il Tuple<T1>.IComparable.CompareTo metodo è destinato all'uso nelle operazioni di ordinamento. Non deve essere usato quando lo scopo principale di un confronto è determinare se due oggetti sono uguali. Per determinare se due oggetti sono uguali, chiamare il Equals metodo .

Il Tuple<T1>.IComparable.CompareTo metodo usa l'operatore di confronto dell'oggetto predefinito.

Vedi anche

• Equals(Object)