Tri des données (C#)

  • Article

Une opération de tri ordonne les éléments d’une séquence en fonction d’un ou de plusieurs attributs. Le premier critère de tri effectue un tri principal sur les éléments. En spécifiant un deuxième critère de tri, vous pouvez trier les éléments dans chaque groupe de tri principal.

L’illustration suivante montre les résultats d’une opération de tri par ordre alphabétique sur une séquence de caractères :

Graphique montrant une opération de tri par ordre alphabétique.

Les méthodes d’opérateurs de requête standard qui trient les données sont répertoriées dans la section suivante.

Méthodes

Nom de la méthode Description Syntaxe d'expression de requête C# Informations complémentaires
OrderBy Trie les valeurs dans l’ordre croissant. orderby Enumerable.OrderBy

Queryable.OrderBy
OrderByDescending Trie les valeurs dans l’ordre décroissant. orderby … descending Enumerable.OrderByDescending

Queryable.OrderByDescending
ThenBy Effectue un tri secondaire dans l’ordre croissant. orderby …, … Enumerable.ThenBy

Queryable.ThenBy
ThenByDescending Effectue un tri secondaire dans l’ordre décroissant. orderby …, … descending Enumerable.ThenByDescending

Queryable.ThenByDescending
Inverser Inverse l’ordre des éléments dans une collection. Non applicable. Enumerable.Reverse

Queryable.Reverse

Les exemples suivants de cet article utilisent les sources de données courantes pour ce domaine :

public enum GradeLevel
{
    FirstYear = 1,
    SecondYear,
    ThirdYear,
    FourthYear
};

public class Student
{
    public required string FirstName { get; init; }
    public required string LastName { get; init; }
    public required int ID { get; init; }

    public required GradeLevel Year { get; init; }
    public required List<int> Scores { get; init; }

    public required int DepartmentID { get; init; }
}

public class Teacher
{
    public required string First { get; init; }
    public required string Last { get; init; }
    public required int ID { get; init; }
    public required string City { get; init; }
}
public class Department
{
    public required string Name { get; init; }
    public int ID { get; init; }

    public required int TeacherID { get; init; }
}

Chaque Student a un niveau scolaire, un département principal et une série de notes. Un Teacher a également une propriété City qui identifie le campus où l’enseignant donne des cours. Un Department a un nom, et une référence à un Teacher qui est responsable du département.

Tri principal croissant

L’exemple suivant montre comment utiliser la clause orderby dans une requête LINQ pour trier les enseignants par nom de famille, dans l’ordre croissant.

IEnumerable<string> query = from teacher in teachers
                            orderby teacher.Last
                            select teacher.Last;

foreach (string str in query)
{
    Console.WriteLine(str);
}

La requête équivalente écrite en utilisant la syntaxe de méthode est illustrée dans le code suivant :

IEnumerable<string> query = teachers
    .OrderBy(teacher => teacher.Last)
    .Select(teacher => teacher.Last);

foreach (string str in query)
{
    Console.WriteLine(str);
}

Tri principal décroissant

L’exemple suivant montre comment utiliser la clause orderby descending dans une requête LINQ pour trier les enseignants par nom de famille, dans l’ordre décroissant.

IEnumerable<string> query = from teacher in teachers
                            orderby teacher.Last descending
                            select teacher.Last;

foreach (string str in query)
{
    Console.WriteLine(str);
}

La requête équivalente écrite en utilisant la syntaxe de méthode est illustrée dans le code suivant :

IEnumerable<string> query = teachers
    .OrderByDescending(teacher => teacher.Last)
    .Select(teacher => teacher.Last);

foreach (string str in query)
{
    Console.WriteLine(str);
}

Tri secondaire croissant

L’exemple suivant montre comment utiliser la clause orderby dans une requête LINQ pour effectuer un tri principal et un tri secondaire. Les enseignants sont triés à titre principal par ville, puis secondairement par nom de famille, les deux tris étant effectuée dans l’ordre croissant.

IEnumerable<(string, string)> query = from teacher in teachers
                            orderby teacher.City, teacher.Last
                            select (teacher.Last, teacher.City);

foreach ((string last, string city) in query)
{
    Console.WriteLine($"City: {city}, Last Name: {last}");
}

La requête équivalente écrite en utilisant la syntaxe de méthode est illustrée dans le code suivant :

IEnumerable<(string, string)> query = teachers
    .OrderBy(teacher => teacher.City)
    .ThenBy(teacher => teacher.Last)
    .Select(teacher => (teacher.Last, teacher.City));

foreach ((string last, string city) in query)
{
    Console.WriteLine($"City: {city}, Last Name: {last}");
}

Tri secondaire décroissant

L’exemple suivant montre comment utiliser la clause orderby descending dans une requête LINQ pour effectuer un tri principal dans l’ordre croissant et un tri secondaire dans l’ordre décroissant. Les enseignants sont triés à titre principal par ville, puis secondairement par nom de famille.

IEnumerable<(string, string)> query = from teacher in teachers
                            orderby teacher.City, teacher.Last descending
                            select (teacher.Last, teacher.City);

foreach ((string last, string city) in query)
{
    Console.WriteLine($"City: {city}, Last Name: {last}");
}

La requête équivalente écrite en utilisant la syntaxe de méthode est illustrée dans le code suivant :

IEnumerable<(string, string)> query = teachers
    .OrderBy(teacher => teacher.City)
    .ThenByDescending(teacher => teacher.Last)
    .Select(teacher => (teacher.Last, teacher.City));

foreach ((string last, string city) in query)
{
    Console.WriteLine($"City: {city}, Last Name: {last}");
}

Voir aussi