Compartir vía


Tuple<T1>.IComparable.CompareTo(Object) Método

Definición

Compara el objeto Tuple<T1> actual con un objeto 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.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

Parámetros

obj
Object

Objeto que se va a comparar con la instancia actual.

Devoluciones

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

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

Implementaciones

Excepciones

obj no es un objeto Tuple<T1>.

Ejemplos

En el ejemplo siguiente se crea una matriz de singletons cuyo componente es un Double valor. Muestra el valor de cada componente de tupla en orden no ordenado, ordena la matriz y, a continuación, muestra los valores en orden ordenado. Tenga en cuenta que el ejemplo no llama directamente al Tuple<T1>.IComparable.CompareTo método . El método llama implícitamente Sort(Array) a este método para cada elemento de la matriz.

using System;

class Example
{
   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);

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

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

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 in sorted order:
//         NaN
//         -Infinity
//         -189.42993
//         -3.588E-12
//         4.94065645841247E-324
//         1.934E-17
//         13.54
//         Infinity
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 In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
        Console.WriteLine()

        Array.Sort(values)

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

Comentarios

Este miembro es una implementación explícita de un miembro de interfaz. Solo se puede utilizar cuando la instancia de Tuple<T1> se convierte en una interfaz IComparable.

Este método proporciona la IComparable.CompareTo implementación de la Tuple<T1> clase . Aunque el método se puede llamar directamente, suele llamarse mediante las sobrecargas predeterminadas de métodos de ordenación de colecciones, como Array.Sort(Array) y SortedList.Add, para ordenar los miembros de una colección.

Precaución

El Tuple<T1>.IComparable.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 Equals método .

El Tuple<T1>.IComparable.CompareTo método usa el comparador de objetos predeterminado.

Se aplica a

Consulte también