Comparer<T> Clase
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í.
Proporciona una clase base para las implementaciones de la interfaz genérica IComparer<T>.
generic <typename T>
public ref class Comparer abstract : System::Collections::Generic::IComparer<T>, System::Collections::IComparerpublic abstract class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer[System.Serializable]
public abstract class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparertype Comparer<'T> = class
interface IComparer<'T>
interface IComparer[<System.Serializable>]
type Comparer<'T> = class
interface IComparer
interface IComparer<'T>Public MustInherit Class Comparer(Of T)
Implements IComparer, IComparer(Of T)Parámetros de tipo
- T
Tipo de objetos que se van a comparar.
- Herencia
-
Comparer<T>
- Atributos
- Implementaciones
Ejemplos
En el ejemplo siguiente se deriva una clase , BoxLengthFirstde la Comparer<T> clase . Este comparador compara dos objetos de tipo Box. Los ordena primero por longitud, luego por alto y, a continuación, por ancho. La Box clase implementa la IComparable<T> interfaz para controlar la comparación predeterminada entre dos Box objetos. Esta implementación predeterminada ordena primero por alto, después por longitud y después por ancho. En el ejemplo se muestran las diferencias entre las dos comparaciones ordenando primero una lista de Box objetos mediante el BoxLengthFirst comparador y, a continuación, mediante el comparador predeterminado.
using System;
using System.Collections;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
List<Box> Boxes = new List<Box>();
Boxes.Add(new Box(4, 20, 14));
Boxes.Add(new Box(12, 12, 12));
Boxes.Add(new Box(8, 20, 10));
Boxes.Add(new Box(6, 10, 2));
Boxes.Add(new Box(2, 8, 4));
Boxes.Add(new Box(2, 6, 8));
Boxes.Add(new Box(4, 12, 20));
Boxes.Add(new Box(18, 10, 4));
Boxes.Add(new Box(24, 4, 18));
Boxes.Add(new Box(10, 4, 16));
Boxes.Add(new Box(10, 2, 10));
Boxes.Add(new Box(6, 18, 2));
Boxes.Add(new Box(8, 12, 4));
Boxes.Add(new Box(12, 10, 8));
Boxes.Add(new Box(14, 6, 6));
Boxes.Add(new Box(16, 6, 16));
Boxes.Add(new Box(2, 8, 12));
Boxes.Add(new Box(4, 24, 8));
Boxes.Add(new Box(8, 6, 20));
Boxes.Add(new Box(18, 18, 12));
// Sort by an Comparer<T> implementation that sorts
// first by the length.
Boxes.Sort(new BoxLengthFirst());
Console.WriteLine("H - L - W");
Console.WriteLine("==========");
foreach (Box bx in Boxes)
{
Console.WriteLine("{0}\t{1}\t{2}",
bx.Height.ToString(), bx.Length.ToString(),
bx.Width.ToString());
}
Console.WriteLine();
Console.WriteLine("H - L - W");
Console.WriteLine("==========");
// Get the default comparer that
// sorts first by the height.
Comparer<Box> defComp = Comparer<Box>.Default;
// Calling Boxes.Sort() with no parameter
// is the same as calling Boxs.Sort(defComp)
// because they are both using the default comparer.
Boxes.Sort();
foreach (Box bx in Boxes)
{
Console.WriteLine("{0}\t{1}\t{2}",
bx.Height.ToString(), bx.Length.ToString(),
bx.Width.ToString());
}
// This explicit interface implementation
// compares first by the length.
// Returns -1 because the length of BoxA
// is less than the length of BoxB.
BoxLengthFirst LengthFirst = new BoxLengthFirst();
Comparer<Box> bc = (Comparer<Box>) LengthFirst;
Box BoxA = new Box(2, 6, 8);
Box BoxB = new Box(10, 12, 14);
int x = LengthFirst.Compare(BoxA, BoxB);
Console.WriteLine();
Console.WriteLine(x.ToString());
}
}
public class BoxLengthFirst : Comparer<Box>
{
// Compares by Length, Height, and Width.
public override int Compare(Box x, Box y)
{
if (x.Length.CompareTo(y.Length) != 0)
{
return x.Length.CompareTo(y.Length);
}
else if (x.Height.CompareTo(y.Height) != 0)
{
return x.Height.CompareTo(y.Height);
}
else if (x.Width.CompareTo(y.Width) != 0)
{
return x.Width.CompareTo(y.Width);
}
else
{
return 0;
}
}
}
// This class is not demonstrated in the Main method
// and is provided only to show how to implement
// the interface. It is recommended to derive
// from Comparer<T> instead of implementing IComparer<T>.
public class BoxComp : IComparer<Box>
{
// Compares by Height, Length, and Width.
public int Compare(Box x, Box y)
{
if (x.Height.CompareTo(y.Height) != 0)
{
return x.Height.CompareTo(y.Height);
}
else if (x.Length.CompareTo(y.Length) != 0)
{
return x.Length.CompareTo(y.Length);
}
else if (x.Width.CompareTo(y.Width) != 0)
{
return x.Width.CompareTo(y.Width);
}
else
{
return 0;
}
}
}
public class Box : IComparable<Box>
{
public Box(int h, int l, int w)
{
this.Height = h;
this.Length = l;
this.Width = w;
}
public int Height { get; private set; }
public int Length { get; private set; }
public int Width { get; private set; }
public int CompareTo(Box other)
{
// Compares Height, Length, and Width.
if (this.Height.CompareTo(other.Height) != 0)
{
return this.Height.CompareTo(other.Height);
}
else if (this.Length.CompareTo(other.Length) != 0)
{
return this.Length.CompareTo(other.Length);
}
else if (this.Width.CompareTo(other.Width) != 0)
{
return this.Width.CompareTo(other.Width);
}
else
{
return 0;
}
}
}
Imports System.Collections.Generic
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim Boxes As New List(Of Box)()
Boxes.Add(New Box(4, 20, 14))
Boxes.Add(New Box(12, 12, 12))
Boxes.Add(New Box(8, 20, 10))
Boxes.Add(New Box(6, 10, 2))
Boxes.Add(New Box(2, 8, 4))
Boxes.Add(New Box(2, 6, 8))
Boxes.Add(New Box(4, 12, 20))
Boxes.Add(New Box(18, 10, 4))
Boxes.Add(New Box(24, 4, 18))
Boxes.Add(New Box(10, 4, 16))
Boxes.Add(New Box(10, 2, 10))
Boxes.Add(New Box(6, 18, 2))
Boxes.Add(New Box(8, 12, 4))
Boxes.Add(New Box(12, 10, 8))
Boxes.Add(New Box(14, 6, 6))
Boxes.Add(New Box(16, 6, 16))
Boxes.Add(New Box(2, 8, 12))
Boxes.Add(New Box(4, 24, 8))
Boxes.Add(New Box(8, 6, 20))
Boxes.Add(New Box(18, 18, 12))
' Sort by an Comparer<T> implementation that sorts
' first by the length.
Boxes.Sort(New BoxLengthFirst())
Console.WriteLine("H - L - W")
Console.WriteLine("==========")
For Each bx As Box In Boxes
Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}", _
bx.Height.ToString(), bx.Length.ToString(), _
bx.Width.ToString())
Next bx
Console.WriteLine()
Console.WriteLine("H - L - W")
Console.WriteLine("==========")
' Get the default comparer that
' sorts first by the height.
Dim defComp As Comparer(Of Box) = Comparer(Of Box).Default
' Calling Boxes.Sort() with no parameter
' is the same as calling Boxs.Sort(defComp)
' because they are both using the default comparer.
Boxes.Sort()
For Each bx As Box In Boxes
Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}", _
bx.Height.ToString(), _
bx.Length.ToString(), _
bx.Width.ToString())
Next bx
' This explicit interface implementation
' compares first by the length.
' Returns -1 because the length of BoxA
' is less than the length of BoxB.
Dim LengthFirst As New BoxLengthFirst()
Dim bc As Comparer(Of Box) = CType(LengthFirst, Comparer(Of Box))
Dim BoxA As New Box(2, 6, 8)
Dim BoxB As New Box(10, 12, 14)
Dim x As Integer = LengthFirst.Compare(BoxA, BoxB)
Console.WriteLine()
Console.WriteLine(x.ToString())
End Sub
End Class
Public Class BoxLengthFirst
Inherits Comparer(Of Box)
' Compares by Length, Height, and Width.
Public Overrides Function Compare(ByVal x As Box, ByVal y As Box) As Integer
If x.Length.CompareTo(y.Length) <> 0 Then
Return x.Length.CompareTo(y.Length)
ElseIf x.Height.CompareTo(y.Height) <> 0 Then
Return x.Height.CompareTo(y.Height)
ElseIf x.Width.CompareTo(y.Width) <> 0 Then
Return x.Width.CompareTo(y.Width)
Else
Return 0
End If
End Function
End Class
' This class is not demonstrated in the Main method
' and is provided only to show how to implement
' the interface. It is recommended to derive
' from Comparer<T> instead of implementing IComparer<T>.
Public Class BoxComp
Implements IComparer(Of Box)
' Compares by Height, Length, and Width.
Public Function Compare(ByVal x As Box, ByVal y As Box) As Integer Implements _
IComparer(Of Box).Compare
If x.Height.CompareTo(y.Height) <> 0 Then
Return x.Height.CompareTo(y.Height)
ElseIf x.Length.CompareTo(y.Length) <> 0 Then
Return x.Length.CompareTo(y.Length)
ElseIf x.Width.CompareTo(y.Width) <> 0 Then
Return x.Width.CompareTo(y.Width)
Else
Return 0
End If
End Function
End Class
Public Class Box
Implements IComparable(Of Box)
Public Sub New(ByVal h As Integer, ByVal l As Integer, ByVal w As Integer)
Me.Height = h
Me.Length = l
Me.Width = w
End Sub
Private privateHeight As Integer
Public Property Height() As Integer
Get
Return privateHeight
End Get
Private Set(ByVal value As Integer)
privateHeight = value
End Set
End Property
Private privateLength As Integer
Public Property Length() As Integer
Get
Return privateLength
End Get
Private Set(ByVal value As Integer)
privateLength = value
End Set
End Property
Private privateWidth As Integer
Public Property Width() As Integer
Get
Return privateWidth
End Get
Private Set(ByVal value As Integer)
privateWidth = value
End Set
End Property
Public Function CompareTo(ByVal other As Box) As Integer _
Implements IComparable(Of Box).CompareTo
' Compares Height, Length, and Width.
If Me.Height.CompareTo(other.Height) <> 0 Then
Return Me.Height.CompareTo(other.Height)
ElseIf Me.Length.CompareTo(other.Length) <> 0 Then
Return Me.Length.CompareTo(other.Length)
ElseIf Me.Width.CompareTo(other.Width) <> 0 Then
Return Me.Width.CompareTo(other.Width)
Else
Return 0
End If
End Function
End Class
Comentarios
Derive de esta clase para proporcionar una implementación personalizada de la IComparer<T> interfaz para su uso con clases de colección como las SortedList<TKey,TValue> clases genéricas y SortedDictionary<TKey,TValue> .
La diferencia entre derivar de la Comparer<T> clase e implementar la System.IComparable interfaz es la siguiente:
Para especificar cómo se deben comparar dos objetos de forma predeterminada, implemente la interfaz en la System.IComparable clase . Esto garantiza que las operaciones de ordenación usarán el código de comparación predeterminado que proporcionó.
Para definir un comparador que se va a usar en lugar del comparador predeterminado, derive de la Comparer<T> clase . A continuación, puede usar este comparador en operaciones de ordenación que toman un comparador como parámetro.
El objeto devuelto por la Default propiedad usa la System.IComparable<T> interfaz genérica (IComparable<T> en C#, IComparable(Of T) en Visual Basic) para comparar dos objetos. Si el tipo T no implementa la System.IComparable<T> interfaz genérica, la Default propiedad devuelve un Comparer<T> que usa la System.IComparable interfaz .
Notas a los implementadores
Compare(T, T) y pueden comportarse de forma diferente en términos de distinción cultural y distinción entre mayúsculas y Equals(T, T) minúsculas.
Para las comparaciones de cadenas, se recomienda la StringComparer clase en Comparer<String>. Las propiedades de la StringComparer clase devuelven instancias predefinidas que realizan comparaciones de cadenas con diferentes combinaciones de distinción cultural y distinción entre mayúsculas y minúsculas. La distinción entre mayúsculas y minúsculas y la distinción cultural son coherentes entre los miembros de la misma StringComparer instancia.
Para obtener más información sobre las comparaciones específicas de la referencia cultural, consulte el espacio de nombres y globalización System.Globalizationy la localización.
Constructores
| Comparer<T>() |
Inicializa una nueva instancia de la clase Comparer<T>. |
Propiedades
| Default |
Devuelve un comparador de criterios de ordenación predeterminado para el tipo especificado por el argumento genérico. |
Métodos
| Compare(T, T) |
Cuando se reemplaza en una clase derivada, realiza una comparación de dos objetos del mismo tipo y devuelve un valor que indica si uno es menor, igual o mayor que el otro. |
| Create(Comparison<T>) |
Crea un comparador mediante la comparación especificada. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
Implementaciones de interfaz explícitas
| IComparer.Compare(Object, Object) |
Compara dos objetos y devuelve un valor que indica si uno de ellos es menor, igual o mayor que el otro. |
Se aplica a
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de