Tuple<T1>.IStructuralComparable.CompareTo(Object, IComparer) Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Tuple.cs

Origem:: Tuple.cs

Origem:: Tuple.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Compara o objeto Tuple<T1> atual com um objeto especificado usando um comparador especificado e retorna um inteiro que indica se o objeto atual está antes, depois ou na mesma posição do objeto especificado na ordem de classificação.

 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

other: Object

Um objeto a ser comparado com a instância atual.

comparer: IComparer

Um objeto que fornece regras personalizadas para comparação.

Retornos

Int32

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

Valor	Descrição
Um inteiro negativo	Esta instância precede `other`.
Zero	Esta instância e `other` têm a mesma posição na ordem de classificação.
Um inteiro positivo	Esta instância segue `other`.

Implementações

CompareTo(Object, IComparer)

Exceções

ArgumentException

other não é um objeto Tuple<T1>.

Exemplos

O exemplo a seguir define uma classe genérica chamada DescendingComparer que implementa a IComparer<T> interface . DescendingComparer classifica objetos em ordem decrescente em vez de crescente invertendo o valor retornado pelo comparador padrão para um tipo específico. Uma instância da classe genérica DescendingComparer é então passada para o Array.Sort(Array, IComparer) método para classificar uma matriz de Tuple<T1> objetos em ordem decrescente. Observe que o exemplo não chama diretamente o IStructuralComparable.CompareTo método . Este método é chamado implicitamente pelo método Array.Sort(Array, IComparer) para cada elemento na matriz.

using System;
using System.Collections.Generic;

public class DescendingComparer<T> : IComparer<T>
{
    public int Compare(T x, T y) 
    {
        return -1 * Comparer<T>.Default.Compare(x, y);
    }
}

class CompareTo2
{
   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, new DescendingComparer<Tuple<Double>>());

       Console.WriteLine("The values sorted in descending 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 sorted in descending order:
//         Infinity
//         13.54
//         1.934E-17
//         4.94065645841247E-324
//         -3.588E-12
//         -189.42993
//         -Infinity
//         NaN

open System
open System.Collections.Generic

type DescendingComparer<'T>() =
    interface IComparer<'T> with
        member _.Compare(x: 'T, y: 'T) = 
            -1 * Comparer<'T>.Default.Compare(x, y)

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, DescendingComparer<Tuple<Double>>())

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 sorted in descending order:
//         Infinity
//         13.54
//         1.934E-17
//         4.94065645841247E-324
//         -3.588E-12
//         -189.42993
//         -Infinity
//         NaN

Imports System.Collections.Generic

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
    Public Function Compare(ByVal x As T, ByVal y As T) As Integer Implements IComparer(Of T).Compare
        Return -1 * Comparer(Of T).Default.Compare(x, y)
    End Function
End Class

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 As Tuple(Of Double) In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
        Console.WriteLine()

        Array.Sort(values, New DescendingComparer(Of Tuple(Of Double)))

        Console.WriteLine("The values sorted in descending order:")
        For Each value As Tuple(Of Double) 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 sorted in descending order:
'         Infinity
'         13.54
'         1.934E-17
'         4.94065645841247E-324
'         -3.588E-12
'         -189.42993
'         -Infinity
'         NaN

Comentários

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

Cuidado

O IStructuralComparable.CompareTo método destina-se ao uso em operações de classificação. Ele não deve ser usado quando a finalidade principal de uma comparação é determinar se dois objetos são iguais. Para determinar se dois objetos são iguais, chame o IStructuralEquatable.Equals método .

Aplica-se a

Confira também

IStructuralEquatable.Equals(Object, IEqualityComparer)

Partilhar via