Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo Método

 virtual int System.Collections.IStructuralComparable.CompareTo(System::Object ^ other, System::Collections::IComparer ^ comparer) = System::Collections::IStructuralComparable::CompareTo;

int IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer);

abstract member System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int
override this.System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int

Function CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareTo

Parâmetros

Devoluções

Um inteiro assinado que indica a posição relativa desta instância e other na ordem de ordenação, conforme mostrado na tabela seguinte.

Implementações

Exceções

Exemplos

O exemplo seguinte cria um conjunto de Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objetos que contém dados populacionais de quatro cidades dos EUA entre 1940 e 2000. O primeiro componente do octuplo é o nome da cidade. Os restantes seis componentes representam a população em intervalos de 10 anos, de 1940 a 2000.

A PopulationComparer classe fornece uma IComparer implementação que permite ordenar o array de octuplos por qualquer um dos seus componentes. Dois valores são fornecidos à PopulationComparer classe no seu construtor: a posição do componente que define a ordem de ordenação e um Boolean valor que indica se os objetos tuplas devem ser ordenados por ordem crescente ou decrescente.

O exemplo mostra então os elementos do array por ordem não ordenada, ordena-os pelo terceiro componente (a população em 1950) e apresenta-os, e depois ordena-os pelo oitavo componente (a população em 2000) e apresenta-os.

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

public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7, T8> : 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 > 8)
         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, Tuple<T8>> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
      if (tX == null)
         return 0;

      Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
      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;
         case 8:
            return Comparer<T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier;
         default:
            return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
      }
   }
}

public class Example
{
   public static void Main()
   {
      // Create array of octuples with population data for three U.S. 
      // cities, 1940-2000.
      Tuple<string, int, int, int, int, int, int, Tuple<int>>[] cities  = 
          { Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),  
            Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) };
      // 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, int>(2)); 
                           
      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1950:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();
      
      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int, int>(8));
                           
      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 2000:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
   }
}
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    
//    Sorted by population in 1950:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 2000:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

open System
open System.Collections
open System.Collections.Generic

type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>(itemPosition, descending) =
    let multiplier = if descending then -1 else 1

    do 
        if itemPosition <= 0 || itemPosition > 8 then
            invalidArg "itemPosition" "The component argument is out of range."
    new(itemPosition) = PopulationComparer (itemPosition, true)

    interface IComparer with
        member _.Compare(x, y) =
            match x with
            | :? Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>> as tX ->
                let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>>
                match itemPosition with
                | 1 ->
                    Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
                | 2 ->
                    Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier
                | 3 ->
                    Comparer<'T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier
                | 4 ->
                    Comparer<'T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier
                | 5 ->
                    Comparer<'T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier
                | 6 ->
                    Comparer<'T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier
                | 7 ->
                    Comparer<'T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier
                | 8 ->
                    Comparer<'T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
                | _ ->
                    Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
            | _ -> 0

// Create array of octuples with population data for three U.S. 
// cities, 1940-2000.
let cities  = 
    [| Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
       Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)  
       Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)  
       Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) |]
// Display array in unsorted order.
printfn "In unsorted order:"
for city in cities do
    printfn $"{city}"
printfn ""

Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int> 2)

// Display array in sorted order.
printfn "Sorted by population in 1950:"
for city in cities do
    printfn $"{city}"
printfn ""

Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int>(8))
                    
// Display array in sorted order.
printfn "Sorted by population in 2000:"
for city in cities do
    printfn $"{city}"
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    
//    Sorted by population in 1950:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 2000:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

Imports System.Collections
Imports System.Collections.Generic

Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7, T8) : Implements IComparer
   Private itemPosition As Integer
   Private multiplier As Integer = -1
      
   Public Sub New(component As Integer)
      Me.New(component, True)
   End Sub
   
   Public Sub New(component As Integer, descending As Boolean)
      If Not descending Then multiplier = 1
      
      If component <= 0 Or component > 8 Then 
         Throw New ArgumentException("The component argument is out of range.")
      End If
      itemPosition = component
   End Sub 
   
   Public Function Compare(x As Object, y As Object) As Integer _
                   Implements IComparer.Compare
 
      Dim tX As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
      If tX Is Nothing Then
         Return 0
      Else
         Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
         Select Case itemPosition
            Case 1
               Return Comparer(Of T1).Default.Compare(tX.Item1, tY.Item1) * multiplier
            Case 2
               Return Comparer(Of T2).Default.Compare(tX.Item2, tY.Item2) * multiplier
            Case 3
               Return Comparer(Of T3).Default.Compare(tX.Item3, tY.Item3) * multiplier
            Case 4
               Return Comparer(Of T4).Default.Compare(tX.Item4, tY.Item4) * multiplier
            Case 5
               Return Comparer(Of T5).Default.Compare(tX.Item5, tY.Item5) * multiplier
            Case 6
               Return Comparer(Of T6).Default.Compare(tX.Item6, tY.Item6) * multiplier
            Case 7
               Return Comparer(Of T7).Default.Compare(tX.Item7, tY.Item7) * multiplier
            Case 8
               Return Comparer(Of T8).Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
         End Select      
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      ' Create array of octuples with population data for three U.S. 
      ' cities, 1940-2000.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),  
            Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) }
      ' 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, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer, Integer)(2)) 
                           
      ' Display array in sorted order.
      Console.WriteLine("Sorted by population in 1950:")
      For Each city In cities
         Console.WriteLine(city.ToString())
      Next
      Console.WriteLine()
      
      Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer, Integer)(8))
                           
      ' Display array in sorted order.
      Console.WriteLine("Sorted by population in 2000:")
      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, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'    
'    Sorted by population in 1950:
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    
'    Sorted by population in 2000:
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

Observações

Este membro é uma implementação explícita de interface. Só pode ser usado quando a Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> instância é transmitida para uma IStructuralComparable interface.

Este método permite-lhe definir comparações personalizadas de Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objetos. Por exemplo, pode usar este método para ordenar Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> objetos com base no valor de um componente específico.

Embora este método possa ser chamado diretamente, é mais frequentemente chamado por métodos de ordenação de coleções que incluem IComparer parâmetros para ordenar os membros de uma coleção. Por exemplo, é chamado pelo Array.Sort(Array, IComparer) método e pelo Add método de um SortedList objeto que é instanciado usando o SortedList.SortedList(IComparer) construtor.