Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

 

Data di pubblicazione: ottobre 2016

Confronta l'oggetto Tuple<T1, T2, T3, T4, T5, T6, T7> oggetto a un oggetto specificato utilizzando un operatore di confronto specificato e restituisce un intero che indica se l'oggetto corrente è precedente, successiva o nella stessa posizione dell'oggetto specificato nell'ordinamento.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

int IStructuralComparable.CompareTo(
	object other,
	IComparer comparer
)

Parametri

other
Type: System.Object

Oggetto da confrontare con l'istanza corrente.

comparer
Type: System.Collections.IComparer

Oggetto che fornisce regole personalizzate per il confronto.

Valore restituito

Type: System.Int32

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

Valore

Descrizione

Intero negativo

Questa istanza precede other.

Zero

Questa istanza e other hanno la stessa posizione nell'ordinamento.

Intero positivo

L'istanza segue other.

Il membro è un'implementazione esplicita dell'interfaccia. e può essere utilizzato solo quando si esegue il cast dell'istanza di Tuple<T1, T2, T3, T4, T5, T6, T7> su un'interfaccia IStructuralComparable.

Questo metodo consente di definire confronti personalizzati di Tuple<T1, T2, T3, T4, T5, T6, T7> oggetti. Ad esempio, è possibile utilizzare questo metodo per ordine Tuple<T1, T2, T3, T4, T5, T6, T7> gli oggetti in base al valore di un componente specifico.

Sebbene questo metodo può essere chiamato direttamente, viene chiamato più di frequente dall'ordinamento raccolta metodi che includono IComparer parametri per ordinare i membri di una raccolta. Ad esempio, viene chiamato Array.Sort(Array, IComparer) (metodo) e Add metodo di un SortedList oggetto che viene creata un'istanza utilizzando il SortedList.SortedList(IComparer) costruttore.

System_CAPS_cautionAttenzione

Il IStructuralComparable.CompareTo metodo è destinato all'utilizzo nelle operazioni di ordinamento. E non deve essere utilizzato quando lo scopo principale di un confronto per determinare se due oggetti sono uguali. Per determinare se due oggetti sono uguali, chiamare il IStructuralEquatable.Equals metodo.

Nell'esempio seguente viene creata una matrice di Tuple<T1, T2, T3, T4, T5, T6, T7> gli oggetti che contiene i dati della popolazione di tre città degli Stati Uniti dal 1950 al 2000. Il primo componente della settupla è il nome della città. I cinque componenti rimanenti rappresentano la popolazione a intervalli di 10 anni dal 1950 al 2000.

La PopulationComparer classe fornisce un IComparer implementazione che consente la matrice di settuple in base a uno qualsiasi dei relativi componenti. Vengono forniti due valori per la PopulationComparer classe nel relativo costruttore: la posizione del componente che definisce l'ordinamento, e un Boolean valore che indica se gli oggetti tupla devono essere ordinati in ordine crescente o decrescente.

Nell'esempio viene quindi Visualizza gli elementi nella matrice in ordine casuale, li ordina in base al terzo componente (la popolazione nel 1960), verranno visualizzati e li ordina in base al sesto componente (la popolazione nel 1990) e li visualizza.

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

public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7> : IComparer
{
   private int itemPosition;
   private int multiplier = -1;

   public PopulationComparer(int component) : this(component, true)
   { }

   public PopulationComparer(int component, bool descending)
   {
      if (! descending) multiplier = 1;

      if (component <= 0 || component > 7)
         throw new ArgumentException("The component argument is out of range.");

      itemPosition = component;
   }

   public int Compare(object x, object y)
   {
      Tuple<T1, T2, T3, T4, T5, T6, T7> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7>;
      if (tX == null)
      {
         return 0;
      }
      else
      {
         Tuple<T1, T2, T3, T4, T5, T6, T7> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7>;
         switch (itemPosition)
         {
            case 1:
               return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
            case 2:
               return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier;
            case 3:
               return Comparer<T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier;
            case 4:
               return Comparer<T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier;
            case 5:
               return Comparer<T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier;
            case 6:
               return Comparer<T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier;
            case 7:
               return Comparer<T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier;
            default:
               return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
         }
      }
   }
}

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, int>[] cities =
           { Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
             Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
             Tuple.Create("Chicago", 3620962, 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, new PopulationComparer<string, int, int, int, int, int, int>(3));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1960:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();

      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int>(6));

      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1990:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
   }
}
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    
//    Sorted by population in 1960:
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 1990:
//    (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 4.0
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: