Comment la méthode de comparaison CompareTo fonctionne-t-elle dans la fonction de tri List?

Question

Comment la méthode de comparaison CompareTo fonctionne dans la fonction de tri List.

public class person : IComparable 
{ 
    string firstName; 
    string lastName; 

    public int CompareTo(object obj) 
    { 
     person otherPerson = (person)obj; 
     if (this.lastName != otherPerson.lastName) 
      return this.lastName.CompareTo(otherPerson.lastName); 
     else 
      return this.firstName.CompareTo(otherPerson.firstName); 
    } 

    public person(string _firstName, string _lastName) 
    { 
     firstName = _firstName; 
     lastName = _lastName; 
    } 

    override public string ToString() 
    { 
     return firstName + " " + lastName; 
    } 
} 

List<person> l = new List<person>(); 
l.Add(new person("Mark", "Hanson")); 
l.Add(new person("Kim", "Akers")); 
l.Add(new person("Zsolt", "Ambrus")); 

l.Sort(); 

foreach (person p in l) 
    Console.WriteLine(p.ToString()); 

Answer 1

Lorsque vous appelez la Sort method sur une liste générique (liste dans votre cas), dans les coulisses, la mise en œuvre de Sort vérifiera si le type de la liste (la classe person) implémente l'interface IComparable, et si elle ne il invoquera le membre CompareTo pour effectuer des comparaisons entre les éléments de la liste pour effectuer le tri. Le fait que la classe person implémente IComparable est interprété comme un "contrat" ​​qui spécifie que la classe person aura une méthode appelée CompareTo.

La mise en œuvre de Sort peut utiliser un extrait tel que ce qui suit pour comparer à des éléments de la liste:

T aPerson; 
T anotherPerson; 
int compareResult; 

if(aPerson is IComparable) 
{ 
    compareResult = (aPerson as IComparable).CompareTo(anotherPerson); 
} 

La méthode CompareTo compare toujours l'objet est invoquée sur le paramètre et le sens de la valeur de retour est toujours le même:

* if the two objects are "equal", it returns 0 
* if the object you are comparing to is "less than" - in a sorted list it goes before - the object you are invoking CompareTo on, it returns -1 
* if the object you are comparing to is "greater than" - in a sorted list it goes after - the object you are invoking CompareTo on, it returns +1 

en interne, la méthode de tri utilise une optimisation QuickSort pour réaliser effectivement le genre, mais pour le rendre plus facile à suivre, voici un exemple de mise en œuvre bubble sort qui illustre ce qui se passe dans les coulisses en termes d'invocation de l'interface IComparable:

// assume the Sort invokes this naive bubble sort 
// on the internal backing array of the list 
void InternalBubbleSort(T[] backingArray) 
{ 
    var swapped = false; 
    do { 
    swapped = false; 
    for(int i = 0; i < Length - 1; i++) { 
     if (backingArray[i].CompareTo(backingArray[i+1]) > 0) { 
     T temp = backingArray[i]; 
     backingArray[i] = backingArray[i+1]; 
     backingArray[i+1] = temp; 
     swapped = true; 
     } 
    }while(swapped); 
} 

Answer 2

Il trie par nom, puis prénom.

Si deux personnes portent le même nom de famille, l'instruction if finira par être comparée par son prénom.
Sinon, il sera comparé par nom de famille.