# IComparer<T> Interface

## Définition

Définit une méthode implémentée par un type pour comparer deux objets.Defines a method that a type implements to compare two objects.

``````generic <typename T>
public interface class IComparer``````
``public interface IComparer<in T>``
``public interface IComparer<T>``
``type IComparer<'T> = interface``
``Public Interface IComparer(Of In T)``
``Public Interface IComparer(Of T)``

#### Paramètres de type

T

Type des objets à comparer.The type of objects to compare.

Ce paramètre de type est contravariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type moins dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.
Dérivé

## Exemples

L’exemple suivant implémente l’interface IComparer<T> pour comparer des objets de type `Box` en fonction de leurs dimensions.The following example implements the IComparer<T> interface to compare objects of type `Box` according to their dimensions. Cet exemple fait partie d’un exemple plus complet fourni pour la classe Comparer<T>.This example is part of a larger example provided for the Comparer<T> 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 : 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;
}
}
}
``````
``````' 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
``````

## Remarques

Cette interface est utilisée avec les méthodes List<T>.Sort et List<T>.BinarySearch.This interface is used with the List<T>.Sort and List<T>.BinarySearch methods. Il fournit un moyen de personnaliser l’ordre de tri d’une collection.It provides a way to customize the sort order of a collection. Les classes qui implémentent cette interface incluent les classes génériques SortedDictionary<TKey,TValue> et SortedList<TKey,TValue>.Classes that implement this interface include the SortedDictionary<TKey,TValue> and SortedList<TKey,TValue> generic classes.

L’implémentation par défaut de cette interface est la classe Comparer<T>.The default implementation of this interface is the Comparer<T> class. La classe StringComparer implémente cette interface pour le type String.The StringComparer class implements this interface for type String.

Cette interface prend en charge les comparaisons de classement.This interface supports ordering comparisons. Autrement dit, lorsque la méthode Compare retourne 0, cela signifie que deux objets sont triés de la même façon.That is, when the Compare method returns 0, it means that two objects sort the same. L’implémentation des comparaisons d’égalité exactes est fournie par l’interface générique IEqualityComparer<T>.Implementation of exact equality comparisons is provided by the IEqualityComparer<T> generic interface.

Nous vous recommandons de dériver de la classe Comparer<T> au lieu d’implémenter l’interface IComparer<T>, car la classe Comparer<T> fournit une implémentation d’interface explicite de la méthode IComparer.Compare et de la propriété Default qui obtient le comparateur par défaut pour l’objet.We recommend that you derive from the Comparer<T> class instead of implementing the IComparer<T> interface, because the Comparer<T> class provides an explicit interface implementation of the IComparer.Compare method and the Default property that gets the default comparer for the object.

## Méthodes

 Compare deux objets et retourne une valeur indiquant si le premier est inférieur, égal ou supérieur au second.Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.