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

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

Tuple.cs

Confronta l'oggetto Tuple<T1,T2,T3,T4,T5,T6> 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

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,T2,T3,T4,T5,T6>.

Esempio

Nell'esempio seguente viene creata una matrice di Tuple<T1,T2,T3,T4,T5,T6> oggetti che contengono dati sulla popolazione per tre città nel Stati Uniti dal 1960 al 2000. I sei componenti sono costituiti dal nome della città seguito dalla popolazione della città a intervalli di 10 anni dal 1960 al 2000. Nell'esempio vengono visualizzati i componenti di ogni tupla nella matrice in ordine non ordinato, ordina la matrice e quindi chiama il ToString metodo 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;

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>[] cities = 
          { Tuple.Create("Los Angeles", 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 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);
                           
      // Display array in sorted order.
      Console.WriteLine("In sorted order:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
   }
}
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    In sorted order:
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)

open System

// Create array of sextuple with population data for three U.S. 
// cities, 1960-2000.
let cities = 
    [| Tuple.Create("Los Angeles", 2479015, 2816061, 2966850, 3485398, 3694820)
       Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278) 
       Tuple.Create("Chicago", 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
                    
// Display array in sorted order.
printfn "In sorted order:"
for city in cities do
    printfn $"{city}"
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    In sorted order:
//    (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7781984, 7894862, 7071639, 7322564, 8008278)

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

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,T5,T6> a un'interfaccia IComparable.

Questo metodo fornisce l'implementazione IComparable.CompareTo per la Tuple<T1,T2,T3,T4,T5,T6> 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 Tuple<T1,T2,T3,T4,T5,T6>.Equals(Object) metodo .

Il IComparable.CompareTo(Object) metodo usa l'operatore di confronto dell'oggetto predefinito per confrontare ogni componente.