différence entre IComparable et IComparer [dupliquer]

comme son nom l'indique, IComparable<T> lit je suis comparable . IComparable<T> quand défini pour T permet de comparer le instance courante avec une autre instance du même type. IComparer<T> lit je suis un comparateur, je compare . IComparer<T> est utilisé pour comparer deux instances de T , généralement en dehors de la portée des instances de T .

comme ce qu'ils sont pour peut être confus au début. De la définition il devrait être clair que donc IComparable<T> (défini dans la classe T elle-même) devrait être la norme de facto pour fournir la logique pour le tri. La valeur par défaut Sort sur List<T> etc. s'appuie sur cela. La mise en œuvre de IComparer<T> sur T ne facilite pas le tri régulier. Par la suite, il y a peu de valeur pour la mise en œuvre de IComparable<T> sur une quelconque autre classe que T . Ceci:

class MyClass : IComparable<T>

a rarement du sens.

d'autre part

class T : IComparable<T>
{
    public int CompareTo(T other)
    {
        //....
    }
}

est la façon de procéder.

IComparer<T> peut être utile lorsque vous avez besoin de tri basé sur une commande personnalisée, mais pas en règle générale. Par exemple, dans une classe de Person à un moment donné, vous pourriez avoir besoin de trier les gens en fonction de leur âge. Dans ce cas, vous pouvez le faire:

class Person
{
    public int Age;
}

class AgeComparer : IComparer<Person>
{
    public int Compare(Person x, Person y)
    {
        return x.Age - y.Age;
    }
}

maintenant le AgeComparer aide à trier une liste basée sur Age .

var people = new Person[] { new Person { age = 23 }, new Person(){ age = 22 } };
people.Sort(p, new AgeComparer()); //person with age 22 comes first now.

de même IComparer<T> sur T n'a pas de sens.

class Person : IComparer<Person>

vrai cela fonctionne, mais ne semble pas bon aux yeux et défait la logique.

habituellement, ce dont vous avez besoin est IComparable<T> . Aussi idéalement, vous pouvez avoir seulement un IComparable<T> tandis que le multiple IComparer<T> est possible sur la base de critères différents.

les IComparer<T> et IComparable<T> sont exactement analogues à IEqualityComparer<T> et IEquatable<T> qui sont utilisés pour tester l'égalité plutôt que de comparer/Trier; un bon fil ici où j'ai écrit la même réponse exacte :)

• IComparable - définit une interface pour un objet avec une méthode CompareTo() qui prend un autre objet du même type et compare l'objet courant à l'objet passé. Il internalise la comparaison à l'objet, permettant une opération de comparaison plus en ligne, et est utile quand il n'y a qu'un seul moyen logique, ou un moyen par défaut massivement commun, pour comparer des objets d'un type.
• IComparer-définit une interface avec une méthode de comparaison() qui prend deux objets d'un autre type (qui n'ont pas à implémenter IComparable) et les compare. Ceci externalise la comparaison, et est utile quand il y a plusieurs façons possibles de comparer deux objets d'un type, ou quand le type n'implémente pas IComparable (ou L'implémentation IComparable compare une manière différente de ce que vous voulez) et que vous n'avez pas le contrôle sur la source de ce type.

la meilleure explication que j'ai lue est" L'objet à trier implémentera IComparable tandis que la classe qui va trier les objets implémentera IComparer."( source )

si les objets que vous essayez de trier n'implémentent pas IComparable, vous devrez créer une classe qui implémente IComparer (et accepte ces types d'objets pour comparaison) et le passer au tableau.Méthode sort ().

IComparable est utilisé pour fournir un ordre de tri par défaut pour vos objets.

IComparer est de fournir des mécanismes de comparaison supplémentaires.

voir cet article pour référence. http://support.microsoft.com/kb/320727

IComparer compare deux objets qu'il est donné. IComparable est mis en œuvre par l'objet qui est comparé, dans le but de comparer avec une autre de lui-même.

C'est une bonne idée de mettre en place IComparable pour le tri des objets. IComparable peut être utile pour le tri par différents critères (par exemple, le tri par un champ sélectionnable dans l'objet).

voir Aussi: Quand utiliser IComparable Vs. IComparer

les objets qui sont des instances de classes qui implémentent IComparable peuvent être comparés à d'autres objets. (Lire IComparable comme "je peux être comparé.") La méthode sur cette interface qui fait cela est CompareTo . Ceci est utile si vous voulez que les instances de telles classes sachent se comparer à d'autres objets.

des Objets qui sont des instances de classes qui implémentent IComparer peut être utilisé pour comparer des paires d'objets. (Lire IComparer comme " je peux comparer.") La méthode sur cette interface qui fait cela est Compare . Ceci est utile si vous souhaitez dissocier la logique de comparaison de la classe des objets comparés. Un cas où vous pourriez utiliser ceci si vous avez différentes façons de comparer des objets (cette comparaison de chaîne de caractères non sensible à la casse versus sensible à la casse).