différence entre IComparable et IComparer

Quelle est la différence entre les IComparable et IComparer ? Est-il nécessaire d’utiliser cette interface toujours avec la méthode Array.Sort()

Comme son nom l’indique, IComparable lit que je suis comparable . IComparable lorsqu’il est défini pour T vous permet de comparer l’ instance actuelle à une autre instance du même type. IComparer lit que je suis un comparateur, je compare . IComparer est utilisé pour comparer deux instances de T , généralement en dehors de la scope des instances de T

En ce qui concerne ce qu’ils sont peuvent être déroutant au premier abord. D’après la définition, il devrait être clair IComparable (défini dans la classe T elle-même) devrait être le standard de facto pour fournir la logique du sorting. Le Sort par défaut sur la List etc repose sur ceci. L’implémentation d’ IComparer sur T n’aide pas le sorting régulier. Par la suite, il y a peu de valeur pour l’implémentation d’ IComparable sur toute autre classe que T Ce:

 class MyClass : IComparable 

fait rarement sens.

D’autre part

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

c’est comme ça que ça doit être fait.

IComparer peut être utile lorsque vous devez sortinger en fonction d’un ordre personnalisé, mais pas en règle générale. Par exemple, dans une classe de Person à un moment donné, vous pourriez avoir besoin de sortinger les personnes en fonction de leur âge. Dans ce cas, vous pouvez faire:

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

AgeComparer aide à sortinger une liste en fonction de l’ 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 sur T n’a pas de sens.

 class Person : IComparer 

C’est vrai, mais cela ne semble pas bon pour les yeux et vainc la logique.

Habituellement, ce dont vous avez besoin est IComparable . Idéalement, vous ne pouvez avoir qu’un seul IComparable alors que plusieurs IComparer sont possibles selon différents critères.

Les IComparer et IComparable sont exactement analogues à IEqualityComparer et IEquatable qui sont utilisés pour tester l’égalité plutôt que pour comparer / sortinger; un bon fil ici où j’ai écrit exactement la même réponse 🙂

  • IComparable – Définit une interface pour un object avec une méthode CompareTo () qui prend un autre object du même type et compare l’object en cours à l’object passé. Il intériorise la comparaison à l’object, ce qui permet une opération de comparaison plus en ligne, et est utile lorsqu’il existe une seule manière logique, ou une méthode par défaut extrêmement commune, de comparer des objects d’un type.
  • IComparer – Définit une interface avec une méthode Compare () qui prend deux objects d’un autre type (qui n’ont pas à implémenter IComparable) et les compare. Cela permet d’extérioriser la comparaison et est utile lorsqu’il existe de nombreuses manières possibles de comparer deux objects d’un type ou lorsque le type n’implémente pas IComparable (ou que l’implémentation IComparable se compare différemment de ce que vous voulez) et que vous ne le faites pas avoir le contrôle sur la source de ce type.

La meilleure explication que j’ai lue est “L’object à sortinger implémentera IComparable alors que la classe qui va sortinger les objects implémentera IComparer.” ( source )

Si les objects que vous essayez de sortinger n’implémentent pas IComparable, vous devrez créer une classe qui implémente IComparer (et accepter ces types d’object pour la comparaison) et la transmettre à la méthode Array.Sort ().

IComparable est utilisé pour fournir un ordre de sorting par défaut pour vos objects.

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

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

IComparer compare deux objects donnés. IComparable est implémenté par l’object comparé, dans le but de le comparer à un autre de lui-même.

C’est une bonne idée d’implémenter IComparable pour le sorting d’objects. IComparable peut être utile pour le sorting selon différents critères (par exemple, sorting par un champ sélectionnable dans l’object).

Voir aussi: Quand utiliser IComparable Vs. IComparer

Les objects qui sont des instances de classes implémentant IComparable peuvent être comparés à d’autres objects. (Lire IComparable comme “je peux être comparé”) La méthode de cette interface est CompareTo . Ceci est utile si vous voulez que les instances de telles classes sachent se comparer aux autres objects.

Les objects qui sont des instances de classes qui implémentent IComparer peuvent être utilisés pour comparer des paires d’objects. (Lire IComparer comme “Je peux comparer.”) La méthode de cette interface est Compare . Ceci est utile si vous souhaitez découpler la logique de comparaison de la classe des objects comparés. Un cas où vous pourriez utiliser ceci si vous avez plusieurs façons de comparer des objects (cette comparaison insensible à la casse ou à la casse).