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

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Source:: Tuple.cs

Source:: Tuple.cs

Source:: Tuple.cs

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Compara el objeto Tuple<T1> actual con un objeto especificado utilizando un comparador especificado y devuelve un entero que indica si el objeto actual precede o sigue al objeto especificado, o si se encuentra en la misma posición que dicho objeto en el criterio de ordenación.

 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

Objeto que se va a comparar con la instancia actual.

comparer: IComparer

Un objeto que proporciona reglas personalizadas para la comparación.

Devoluciones

Int32

Entero con signo que indica la posición relativa de esta instancia y other en el criterio de ordenación, tal como se muestra en la tabla siguiente.

Valor	Descripción
Un entero negativo	Esta instancia precede a `other`.
Cero	En el criterio de ordenación, esta instancia y `other` tienen la misma posición.
Un entero positivo.	Esta instancia es posterior a `other`.

Implementaciones

CompareTo(Object, IComparer)

Excepciones

ArgumentException

other no es un objeto Tuple<T1>.

Ejemplos

En el ejemplo siguiente se define una clase genérica denominada DescendingComparer que implementa la IComparer<T> interfaz . DescendingComparer ordena los objetos en orden descendente en lugar de ascendente al invertir el valor devuelto por el comparador predeterminado para un tipo determinado. A continuación, se pasa una instancia de la clase genérica DescendingComparer al Array.Sort(Array, IComparer) método para ordenar una matriz de Tuple<T1> objetos en orden descendente. Tenga en cuenta que el ejemplo no llama directamente al IStructuralComparable.CompareTo método . El método llama implícitamente Array.Sort(Array, IComparer) a este método para cada elemento de la 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

Comentarios

Aunque se puede llamar directamente a este método, normalmente se llama mediante métodos de ordenación de colecciones que incluyen IComparer parámetros para ordenar los miembros de una colección. Por ejemplo, se llama mediante el Array.Sort(Array, IComparer) método y el Add método de un SortedList objeto al que se crea una instancia mediante el SortedList.SortedList(IComparer) constructor .

Precaución

El IStructuralComparable.CompareTo método está pensado para su uso en operaciones de ordenación. No se debe usar cuando el propósito principal de una comparación es determinar si dos objetos son iguales. Para determinar si dos objetos son iguales, llame al IStructuralEquatable.Equals método .

Se aplica a

Consulte también

IStructuralEquatable.Equals(Object, IEqualityComparer)

Compartir vía