Tuple<T1,T2>.IStructuralComparable.CompareTo(Object, IComparer) Método
Definición
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,T2> 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 -> intFunction CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareToPará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
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
Excepciones
other no es un objeto Tuple<T1,T2>.
Ejemplos
En el ejemplo siguiente se crea una matriz de Tuple<T1,T2> objetos que constan del nombre y la puntuación de prueba de un alumno. Muestra el componente de cada tupla de la matriz en orden no ordenado, ordena la matriz y, a continuación, llama ToString a para mostrar el valor de cada tupla en orden ordenado. Para ordenar la matriz, el ejemplo define una clase genérica ScoreComparer que implementa la IComparer interfaz y ordena los Tuple<T1,T2> objetos en orden ascendente por el valor de su segundo componente en lugar de su primer componente. 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;
using System.Collections.Generic;
public class ScoreComparer<T1, T2> : IComparer
{
public int Compare(object x, object y)
{
Tuple<T1, T2> tX = x as Tuple<T1,T2>;
if (tX == null)
{
return 0;
}
else
{
Tuple<T1, T2> tY = y as Tuple<T1, T2>;
return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2);
}
}
}
public class Example
{
public static void Main()
{
Tuple<string, Nullable<int>>[] scores =
{ new Tuple<string, Nullable<int>>("Jack", 78),
new Tuple<string, Nullable<int>>("Abbey", 92),
new Tuple<string, Nullable<int>>("Dave", 88),
new Tuple<string, Nullable<int>>("Sam", 91),
new Tuple<string, Nullable<int>>("Ed", null),
new Tuple<string, Nullable<int>>("Penelope", 82),
new Tuple<string, Nullable<int>>("Linda", 99),
new Tuple<string, Nullable<int>>("Judith", 84) };
Console.WriteLine("The values in unsorted order:");
foreach (var score in scores)
Console.WriteLine(score.ToString());
Console.WriteLine();
Array.Sort(scores, new ScoreComparer<string, Nullable<int>>());
Console.WriteLine("The values in sorted order:");
foreach (var score in scores)
Console.WriteLine(score.ToString());
}
}
// The example displays the following output;
// The values in unsorted order:
// (Jack, 78)
// (Abbey, 92)
// (Dave, 88)
// (Sam, 91)
// (Ed, )
// (Penelope, 82)
// (Linda, 99)
// (Judith, 84)
//
// The values in sorted order:
// (Ed, )
// (Jack, 78)
// (Penelope, 82)
// (Judith, 84)
// (Dave, 88)
// (Sam, 91)
// (Abbey, 92)
// (Linda, 99)
open System
open System.Collections
open System.Collections.Generic
type ScoreComparer<'T1, 'T2>() =
interface IComparer with
member _.Compare(x: obj, y: obj) =
match x with
| :? Tuple<'T1, 'T2> as tX ->
let tY = y :?> Tuple<'T1, 'T2>
Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2)
| _ -> 0
let scores =
[| Tuple<string, Nullable<int>>("Jack", 78)
Tuple<string, Nullable<int>>("Abbey", 92)
Tuple<string, Nullable<int>>("Dave", 88)
Tuple<string, Nullable<int>>("Sam", 91)
Tuple<string, Nullable<int>>("Ed", Nullable())
Tuple<string, Nullable<int>>("Penelope", 82)
Tuple<string, Nullable<int>>("Linda", 99)
Tuple<string, Nullable<int>>("Judith", 84) |]
printfn "The values in unsorted order:"
for score in scores do
printfn $"{score}"
printfn ""
Array.Sort(scores, ScoreComparer<string, Nullable<int>>())
printfn "The values in sorted order:"
for score in scores do
printfn $"{score}"
// The example displays the following output
// The values in unsorted order:
// (Jack, 78)
// (Abbey, 92)
// (Dave, 88)
// (Sam, 91)
// (Ed, )
// (Penelope, 82)
// (Linda, 99)
// (Judith, 84)
//
// The values in sorted order:
// (Ed, )
// (Jack, 78)
// (Penelope, 82)
// (Judith, 84)
// (Dave, 88)
// (Sam, 91)
// (Abbey, 92)
// (Linda, 99)
Imports System.Collections
Imports System.Collections.Generic
Public Class ScoreComparer(Of T1, T2) : Implements IComparer
Public Function Compare(x As Object, y As Object) As Integer _
Implements IComparer.Compare
Dim tX As Tuple(Of T1, T2) = TryCast(x, Tuple(Of T1, T2))
If tX Is Nothing Then
Return 0
Else
Dim tY As Tuple(Of T1, T2) = DirectCast(y, Tuple(Of T1, T2))
Return Comparer(Of T2).Default.Compare(tx.Item2, tY.Item2)
End If
End Function
End Class
Module Example
Public Sub Main()
Dim scores() As Tuple(Of String, Nullable(Of Integer)) =
{ New Tuple(Of String, Nullable(Of Integer))("Jack", 78),
New Tuple(Of String, Nullable(Of Integer))("Abbey", 92),
New Tuple(Of String, Nullable(Of Integer))("Dave", 88),
New Tuple(Of String, Nullable(Of Integer))("Sam", 91),
New Tuple(Of String, Nullable(Of Integer))("Ed", Nothing),
New Tuple(Of String, Nullable(Of Integer))("Penelope", 82),
New Tuple(Of String, Nullable(Of Integer))("Linda", 99),
New Tuple(Of String, Nullable(Of Integer))("Judith", 84) }
Console.WriteLine("The values in unsorted order:")
For Each score In scores
Console.WriteLine(score.ToString())
Next
Console.WriteLine()
Array.Sort(scores, New ScoreComparer(Of String, Nullable(Of Integer))())
Console.WriteLine("The values in sorted order:")
For Each score In scores
Console.WriteLine(score.ToString())
Next
End Sub
End Module
' The example displays the following output;
' The values in unsorted order:
' (Jack, 78)
' (Abbey, 92)
' (Dave, 88)
' (Sam, 91)
' (Ed, )
' (Penelope, 82)
' (Linda, 99)
' (Judith, 84)
'
' The values in sorted order:
' (Ed, )
' (Jack, 78)
' (Penelope, 82)
' (Judith, 84)
' (Dave, 88)
' (Sam, 91)
' (Abbey, 92)
' (Linda, 99)
Comentarios
Este miembro es una implementación explícita de un miembro de interfaz. Solo se puede utilizar cuando la instancia de Tuple<T1,T2> se convierte en una interfaz IStructuralComparable.
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 .