Tri des listes d’objets en C# : efficacité optimale

Trier efficacement des listes d’objets par une propriété spécifique est une compétence cruciale pour tout développeur C#. Cet article explore deux approches principales : l’utilisation de la méthode OrderBy de LINQ et l’utilisation de la méthode List<T>.Sort avec des délégués. Nous examinerons les forces et les faiblesses de chacune, vous aidant à choisir la meilleure méthode pour vos besoins spécifiques.

Table des matières

• Utilisation de la méthode OrderBy de LINQ
• Utilisation de délégués avec List<T>.Sort
• Choisir la bonne méthode

Utilisation de la méthode OrderBy de LINQ

La méthode OrderBy de LINQ fournit un moyen propre et lisible de trier les listes. Elle utilise des expressions lambda pour spécifier les critères de tri et renvoie une nouvelle liste triée, laissant la liste originale intacte. Ceci est idéal lorsque vous devez préserver les données d’origine.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Example
{
    public static void Main(string[] args)
    {
        List<Person> people = new List<Person>()
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        // Trier par Nom (croissant)
        var sortedByName = people.OrderBy(p => p.Name).ToList();

        Console.WriteLine("Trié par Nom :");
        PrintPeople(sortedByName);

        // Trier par Âge (décroissant)
        var sortedByAgeDescending = people.OrderByDescending(p => p.Age).ToList();

        Console.WriteLine("nTrié par Âge (Décroissant) :");
        PrintPeople(sortedByAgeDescending);
    }

    static void PrintPeople(List<Person> people)
    {
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Utilisation de délégués avec List<T>.Sort

Pour les situations exigeant plus de contrôle ou nécessitant la réutilisation de la logique de tri, les délégués offrent une alternative puissante. La méthode List<T>.Sort trie la liste *sur place*, modifiant directement la liste d’origine. Cela peut être plus efficace pour les très grandes listes, mais n’oubliez pas que cela modifie les données d’origine.

using System;
using System.Collections.Generic;

// ... classe Person ci-dessus ...

public class Example
{
    public static void Main(string[] args)
    {
        List<Person> people = new List<Person>()
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        // Trier par Nom (croissant) en utilisant un délégué
        people.Sort((p1, p2) => p1.Name.CompareTo(p2.Name));

        Console.WriteLine("Trié par Nom (Sur place) :");
        PrintPeople(people);

        // Trier par Âge (décroissant) en utilisant un délégué
        people.Sort((p1, p2) => p2.Age.CompareTo(p1.Age)); // Notez l'ordre inversé pour le classement décroissant

        Console.WriteLine("nTrié par Âge (Décroissant, Sur place) :");
        PrintPeople(people);
    }
    // ... méthode PrintPeople ci-dessus ...
}

Choisir la bonne méthode

L’approche optimale dépend de vos exigences spécifiques :

• OrderBy (LINQ) : Idéal pour les tâches de tri simples où la préservation de la liste d’origine est cruciale. Elle est généralement plus lisible.
• List<T>.Sort (avec délégués) : Offre un plus grand contrôle et peut être plus efficace pour les très grandes listes lorsque la modification de la liste d’origine est acceptable. Utile pour une logique de comparaison complexe ou des fonctions de tri réutilisables.

Examinez attentivement si vous devez conserver l’ordre de la liste d’origine et les implications sur les performances de votre application avant de faire votre choix.