C# Academy · Leçon

IComparer pour un tri personnalisé

Fournissez d’autres ordres de tri avec des comparateurs.

Leçon 4 sur 413 étapes

IComparer pour un tri personnalisé est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Trier de différentes façons

Un type ne possède qu'un seul ordre naturel via IComparable<T>. Pour trier les mêmes données autrement, fournissez un IComparer<T> ou un délégué Comparison<T> au site d'appel.

Implémenter IComparer<T>

Un IComparer<T> est un objet distinct doté d'une méthode Compare(x, y). Il suit le même contrat de valeurs négative, nulle ou positive que CompareTo.

using System;
using System.Collections.Generic;

public class Person
{
    public string Name;
    public int Age;
    public Person(string name, int age) { Name = name; Age = age; }
    public override string ToString() => Name + "(" + Age + ")";
}

public class ByName : IComparer<Person>
{
    public int Compare(Person x, Person y)
        => string.Compare(x.Name, y.Name, StringComparison.Ordinal);
}

public class Program
{
    public static void Main()
    {
        var people = new List<Person> { new Person("Zoe", 1), new Person("Ann", 2) };
        people.Sort(new ByName());
        Console.WriteLine(string.Join(", ", people));
    }
}

Plusieurs comparateurs pour un même type

Vous pouvez définir plusieurs comparateurs et en choisir un pour chaque tri. Ici, les mêmes personnes peuvent être triées par nom ou par âge à la demande.

using System;
using System.Collections.Generic;

public class Person
{
    public string Name;
    public int Age;
    public Person(string name, int age) { Name = name; Age = age; }
    public override string ToString() => Name + "(" + Age + ")";
}

public class ByAge : IComparer<Person>
{
    public int Compare(Person x, Person y) => x.Age.CompareTo(y.Age);
}

public class Program
{
    public static void Main()
    {
        var people = new List<Person> { new Person("Ann", 40), new Person("Bo", 20) };
        people.Sort(new ByAge());
        Console.WriteLine(string.Join(", ", people));
    }
}

Délégué Comparison<T>

Pour les tris ponctuels, un délégué Comparison<T> (souvent une lambda) est plus concis qu'une classe entière. List.Sort l'accepte directement.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var words = new List<string> { "banana", "fig", "apple" };
        // Sort by length using a Comparison<string> lambda
        words.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine(string.Join(", ", words));
    }
}

Ordre décroissant avec un comparateur

Inversez un ordre en échangeant les opérandes dans Compare. Vous obtenez ainsi un tri décroissant sans modifier le type lui-même.

using System;
using System.Collections.Generic;

public class DescendingInt : IComparer<int>
{
    public int Compare(int x, int y) => y.CompareTo(x);
}

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 3, 1, 4, 1, 5 };
        nums.Sort(new DescendingInt());
        Console.WriteLine(string.Join(", ", nums));
    }
}

Comparateurs dans OrderBy

LINQ OrderBy accepte un IComparer<TKey> comme second argument, ce qui vous permet de personnaliser la comparaison des clés sélectionnées.

using System;
using System.Collections.Generic;
using System.Linq;

public class CaseInsensitive : IComparer<string>
{
    public int Compare(string x, string y)
        => string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
}

public class Program
{
    public static void Main()
    {
        var names = new[] { "bob", "Alice", "carol" };
        foreach (var n in names.OrderBy(x => x, new CaseInsensitive()))
            Console.WriteLine(n);
    }
}

Comparaison sur plusieurs clés

Un comparateur peut trier selon plusieurs clés dans l'ordre de priorité. Calculez la première clé ; en cas d'égalité, passez à la suivante.

using System;
using System.Collections.Generic;

public class Employee
{
    public string Dept;
    public int Salary;
    public Employee(string dept, int salary) { Dept = dept; Salary = salary; }
    public override string ToString() => Dept + ":" + Salary;
}

public class ByDeptThenSalary : IComparer<Employee>
{
    public int Compare(Employee x, Employee y)
    {
        int byDept = string.Compare(x.Dept, y.Dept, StringComparison.Ordinal);
        return byDept != 0 ? byDept : x.Salary.CompareTo(y.Salary);
    }
}

public class Program
{
    public static void Main()
    {
        var staff = new List<Employee>
        {
            new Employee("IT", 50), new Employee("HR", 40), new Employee("IT", 30)
        };
        staff.Sort(new ByDeptThenSalary());
        Console.WriteLine(string.Join(", ", staff));
    }
}

Raccourci Comparer.Create

Comparer<T>.Create construit un IComparer<T> à partir d'une lambda, en associant la concision d'un délégué aux API d'interface qui exigent un comparateur.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var byLengthDesc = Comparer<string>.Create((a, b) => b.Length.CompareTo(a.Length));
        var words = new List<string> { "hi", "hello", "hey" };
        words.Sort(byLengthDesc);
        Console.WriteLine(string.Join(", ", words));
    }
}

Réutiliser les comparateurs dans plusieurs collections

Une même instance de comparateur peut piloter le tri, la recherche et les ensembles ordonnés. Le définir une seule fois garantit la cohérence des règles d'ordre partout où elles sont utilisées.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        IComparer<int> desc = Comparer<int>.Create((a, b) => b.CompareTo(a));
        var set = new SortedSet<int>(desc) { 1, 5, 3 };
        Console.WriteLine(string.Join(", ", set));
    }
}

Choisir entre IComparable et IComparer

Utilisez IComparable<T> pour l'unique ordre naturel intégré au type. Utilisez IComparer<T> ou Comparison<T> pour les différents ordres alternatifs et contextuels que vous définissez au site d'appel.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 5, 2, 8, 1 };
        nums.Sort(); // natural ascending (int is IComparable)
        Console.WriteLine(string.Join(", ", nums));
        nums.Sort((a, b) => b - a); // custom descending via delegate
        Console.WriteLine(string.Join(", ", nums));
    }
}

À vous de jouer

Triez une liste de trois façons différentes à l'aide de comparateurs et d'une lambda, sans toucher au type des éléments.

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var words = new List<string> { "pear", "fig", "apple", "kiwi" };

        words.Sort(); // natural alphabetical
        Console.WriteLine(string.Join(", ", words));

        words.Sort((a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", words));

        words.Sort(Comparer<string>.Create((a, b) => b.CompareTo(a))); // reverse alphabetical
        Console.WriteLine(string.Join(", ", words));
    }
}

Vérification rapide

Choisissez la bonne abstraction d'ordre.

Réponds-y dans la leçon interactive

Récapitulatif

Le tri personnalisé utilise des comparateurs fournis au site d'appel.

IComparer<T> implémente Compare(x, y) avec le contrat de valeurs négative, nulle ou positive.
Les délégués Comparison<T> et les lambdas conviennent aux tris ponctuels.
Comparer<T>.Create fait le lien entre les lambdas et l'interface.
Utilisez IComparable pour l'ordre naturel et les comparateurs pour les ordres alternatifs.

Gratuit pour commencer

Apprends C# avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 93
Leçons: 346

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « IComparer pour un tri personnalisé » est-elle gratuite ?

Oui — le texte complet de « IComparer pour un tri personnalisé » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « IComparer pour un tri personnalisé » ?

Fournissez d’autres ordres de tri avec des comparateurs. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « IComparer pour un tri personnalisé » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy