C# Academy · Les

IComparer voor aangepast sorteren

Bied alternatieve volgordes met comparers.

Les 4 van 413 stappen

IComparer voor aangepast sorteren is een gratis C# Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Op verschillende manieren sorteren

Een type heeft via IComparable<T> maar één natuurlijke volgorde. Als je dezelfde gegevens op andere manieren wilt sorteren, geef je op de plek van de aanroep een IComparer<T> of een Comparison<T>-delegate mee.

IComparer<T> implementeren

Een IComparer<T> is een afzonderlijk object met een Compare(x, y)-methode. Het volgt hetzelfde contract van negatief, nul en positief als 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));
    }
}

Meerdere vergelijkers voor één type

Je kunt meerdere vergelijkers definiëren en er per sortering één kiezen. Hier kunnen dezelfde mensen op verzoek op naam of leeftijd worden gesorteerd.

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));
    }
}

Comparison<T>-delegate

Voor eenmalige sorteringen is een Comparison<T>-delegate, vaak een lambda, beknopter dan een volledige klasse. List.Sort accepteert deze rechtstreeks.

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));
    }
}

Aflopend sorteren met een vergelijker

Keer een volgorde om door de operanden in Compare om te wisselen. Zo krijg je een aflopende sortering zonder het type zelf aan te passen.

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));
    }
}

Vergelijkers in OrderBy

LINQ OrderBy accepteert een IComparer<TKey> als tweede argument, zodat je kunt aanpassen hoe de geselecteerde sleutels worden vergeleken.

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);
    }
}

Vergelijking op meerdere sleutels

Een vergelijker kan op meerdere sleutels in volgorde van prioriteit sorteren. Bereken de eerste sleutel; als die gelijk is, ga je door met de volgende.

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));
    }
}

Snelkoppeling met Comparer.Create

Comparer<T>.Create bouwt een IComparer<T> op basis van een lambda en combineert de beknoptheid van een delegate met de API's van interfaces waarvoor een vergelijker nodig is.

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));
    }
}

Vergelijkers hergebruiken in verschillende verzamelingen

Een enkele instantie van een vergelijker kan sorteren, zoeken en geordende verzamelingen aansturen. Door deze één keer te definiëren, blijven de ordeningsregels overal hetzelfde.

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));
    }
}

IComparable of IComparer kiezen

Gebruik IComparable<T> voor de ene natuurlijke volgorde die in het type is ingebouwd. Gebruik IComparer<T> of Comparison<T> voor de vele alternatieve, contextafhankelijke volgorden die je op de plek van de aanroep bepaalt.

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));
    }
}

Probeer het zelf

Sorteer één lijst op drie verschillende manieren met vergelijkers en een lambda, zonder het elementtype aan te raken.

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));
    }
}

Snelle controle

Kies de juiste abstractie voor volgordebepaling.

Beantwoord dit in de interactieve les

Samenvatting

Aangepast sorteren gebruikt vergelijkers die je op de plek van de aanroep meegeeft.

IComparer<T> implementeert Compare(x, y) met het contract van negatief, nul en positief.
Comparison<T>-delegates en lambda's zijn geschikt voor eenmalige sorteringen.
Comparer<T>.Create verbindt lambda's met de interface.
Gebruik IComparable voor de natuurlijke volgorde en vergelijkers voor alternatieve volgorden.

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “IComparer voor aangepast sorteren” gratis?

Ja — de volledige tekst van “IComparer voor aangepast sorteren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “IComparer voor aangepast sorteren”?

Bied alternatieve volgordes met comparers. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “IComparer voor aangepast sorteren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy