Condividi tramite


Tuple<T1,T2,T3,T4>.IComparable.CompareTo(Object) Metodo

Definizione

Confronta l'oggetto Tuple<T1,T2,T3,T4> corrente con un oggetto specificato e restituisce un intero che indica se l'oggetto corrente precede, segue o si trova nella stessa posizione dell'oggetto specificato nell'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

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

Eccezioni

obj non è un oggetto Tuple<T1,T2,T3,T4>.

Esempio

Nell'esempio seguente viene creata una matrice di Tuple<T1,T2,T3,T4> oggetti i cui componenti sono costituiti dal nome del pitcher del baseball, dal numero di inning e dal numero di colpi e dalle esecuzioni ottenute. Visualizza i componenti di ogni tupla nella matrice in ordine non ordinato, ordina la matrice e quindi chiama ToString per visualizzare ogni tupla in ordine ordinato. L'output mostra che la matrice è stata ordinata in base al nome, ovvero il primo componente. Si noti che l'esempio non chiama direttamente il IComparable.CompareTo(Object) metodo . Questo metodo viene chiamato in modo implicito dal Sort(Array) metodo per ogni elemento nella matrice.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Tuple<string, decimal, int, int>[] pitchers  =  
                      { Tuple.Create("McHale, Joe", 240.1m, 221, 96),
                        Tuple.Create("Paul, Dave", 233.1m, 231, 84), 
                        Tuple.Create("Williams, Mike", 193.2m, 183, 86),
                        Tuple.Create("Blair, Jack", 168.1m, 146, 65), 
                        Tuple.Create("Henry, Walt", 140.1m, 96, 30),
                        Tuple.Create("Lee, Adam", 137.2m, 109, 45),
                        Tuple.Create("Rohr, Don", 101.0m, 110, 42) };

      // Display the array in unsorted order.
      Console.WriteLine("The values in unsorted order:");
      foreach (var pitcher in pitchers)
         Console.WriteLine(pitcher.ToString());
      Console.WriteLine();
      
      // Sort the array
      Array.Sort(pitchers);
      
      // Display the array in sorted order.
      Console.WriteLine("The values in sorted order:");
      foreach (var pitcher in pitchers)
         Console.WriteLine(pitcher.ToString());
   }
}
// The example displays the following output;
//       The values in unsorted order:
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Williams, Mike, 193.2, 183, 86)
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (Rohr, Don, 101, 110, 42)
//       
//       The values in sorted order:
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Rohr, Don, 101, 110, 42)
//       (Williams, Mike, 193.2, 183, 86)
open System

let pitchers  =  
    [| Tuple.Create("McHale, Joe", 240.1m, 221, 96)
       Tuple.Create("Paul, Dave", 233.1m, 231, 84)
       Tuple.Create("Williams, Mike", 193.2m, 183, 86)
       Tuple.Create("Blair, Jack", 168.1m, 146, 65)
       Tuple.Create("Henry, Walt", 140.1m, 96, 30)
       Tuple.Create("Lee, Adam", 137.2m, 109, 45)
       Tuple.Create("Rohr, Don", 101.0m, 110, 42) |]

// Display the array in unsorted order.
printfn "The values in unsorted order:"
for pitcher in pitchers do
    printfn $"{pitcher}"
printfn ""

// Sort the array
Array.Sort pitchers

// Display the array in sorted order.
printfn "The values in sorted order:"
for pitcher in pitchers do
    printfn $"{pitcher}"
// The example displays the following output
//       The values in unsorted order:
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Williams, Mike, 193.2, 183, 86)
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (Rohr, Don, 101, 110, 42)
//       
//       The values in sorted order:
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Rohr, Don, 101, 110, 42)
//       (Williams, Mike, 193.2, 183, 86)
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim pitchers() =  
                { Tuple.Create("McHale, Joe", 240.1d, 221, 96),
                  Tuple.Create("Paul, Dave", 233.1d, 231, 84), 
                  Tuple.Create("Williams, Mike", 193.2d, 183, 86),
                  Tuple.Create("Blair, Jack", 168.1d, 146, 65), 
                  Tuple.Create("Henry, Walt", 140.1d, 96, 30),
                  Tuple.Create("Lee, Adam", 137.2d, 109, 45),
                  Tuple.Create("Rohr, Don", 101.0d, 110, 42) }

      ' Display the array in unsorted order.
      Console.WriteLine("The values in unsorted order:")
      For Each pitcher In pitchers
         Console.WriteLine(pitcher.ToString())
      Next
      Console.WriteLine()
      
      ' Sort the array
      Array.Sort(pitchers)
      
      ' Display the array in sorted order.
      Console.WriteLine("The values in sorted order:")
      For Each pitcher In pitchers
         Console.WriteLine(pitcher.ToString())
      Next
   End Sub
End Module
' The example displays the following output:
'       The values in unsorted order:
'       (McHale, Joe, 240.1, 221, 96)
'       (Paul, Dave, 233.1, 231, 84)
'       (Williams, Mike, 193.2, 183, 86)
'       (Blair, Jack, 168.1, 146, 65)
'       (Henry, Walt, 140.1, 96, 30)
'       (Lee, Adam, 137.2, 109, 45)
'       (Rohr, Don, 101, 110, 42)
'       
'       The values in sorted order:
'       (Blair, Jack, 168.1, 146, 65)
'       (Henry, Walt, 140.1, 96, 30)
'       (Lee, Adam, 137.2, 109, 45)
'       (McHale, Joe, 240.1, 221, 96)
'       (Paul, Dave, 233.1, 231, 84)
'       (Rohr, Don, 101, 110, 42)
'       (Williams, Mike, 193.2, 183, 86)

Commenti

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

Questo metodo fornisce l'implementazione IComparable.CompareTo per la Tuple<T1,T2,T3,T4> classe . Anche se il metodo può essere chiamato direttamente, viene chiamato in genere dagli overload predefiniti dei metodi di ordinamento delle raccolte, ad esempio Array.Sort(Array) e SortedList.Add, per ordinare i membri di una raccolta.

Attenzione

Il IComparable.CompareTo metodo è destinato all'uso nelle operazioni di ordinamento. Non deve essere utilizzato 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 IComparable.CompareTo metodo usa l'operatore di confronto dell'oggetto predefinito per confrontare ogni componente.

Si applica a

Vedi anche