Tri un tableau d'objet en C# (équivalent de std :: sort)

Question

Comment puis-je trier tableau de chaînes ascendantes C#, je veux utiliser quelque chose comme std :: sort en C++:

std::sort(population.begin(), population.end()) 

Je dois trier la liste des obects. Les objets de la liste sont des instances de la classe Génome. J'ai surchargé l'opérateur < et l'opérateur > dans cette classe.

class Genome 
{ 
    public List<double> weights; 
    public double fitness; 

    public Genome() 
    { 
     fitness = 0.0; 
     weights = new List<double>(); 
    } 

    public Genome(List<double> weights, double fitness) { 
     this.weights = weights; 
     this.fitness = fitness; 
    } 


    public static bool operator <(Genome lhs, Genome rhs) 
    { 
     return (lhs.fitness < rhs.fitness); 
    } 

    public static bool operator >(Genome lhs, Genome rhs) { 
     return (lhs.fitness > rhs.fitness); 
    } 

} 

Voici comment la population est déclarée:

List<Genome> population = new List<Genome>(); 

Comment puis-je trier ce tableau ?? Peut être utilisé l'opérateur surchargé opérateur < comme en C++?

Answer 1

population.OrderBy(x => x.weights); 

ou:

population.OrderByDescending(x => x.fitness); 

Answer 2

Contrairement à C++ qui repose sur operator< pour le tri, C# repose sur la mise en œuvre de IComparable<T> par votre classe ou prend un comparateur externe passé à Sort méthode:

class Genome : IComparable<Genome> { 
    public int CompareTo(Genome other) { 
     return fitness.CompareTo(other.fitness); 
    } 
} 

L'opérateur peut être surchargé pour < être utilisé, comme en C++?

IComparable<T> est un peu plus complexe que <, car il renvoie zéro lorsque les objets sont égaux. Vous pouvez exprimer la même logique en utilisant < et >, mais il est plus facile d'implémenter l'interface IComparable<T> directement.

Answer 3

La façon dont vous définissez l'ordre des objets (< et>) n'est pas appropriée pour C#.

Vous devez réaliser l'interface IComparable. Il a une seule méthode:

public interface IComparable 
{ 
    int CompareTo(object o); 
} 

La méthode CompareTo est utilisée pour comparer l'objet avec un autre objet. Il retourne un nombre:

1. moins 0. L'objet courant sera avant que l'objet qui est dans l'argumentation
2. est égal à 0. Deux objets sont égaux
3. Plus de 0. objet actuel sera après l'objet qui est dans l'argumentation

Par exemple:

class Paper: IComparable 
{ 
    public int width; 
    public int height; 
    public int CompareTo(object o) 
    { 
     Paper p = o as Paper; 
     if (p!=null) 
     { 
      return this.width*this.height-p.width*p.height 
     } 
} 

dans votre cas, il vous suffit de retourner this.fitnes s-p.fitness.