0Pricing
C# Academy · Lektion

IComparer für benutzerdefinierte Sortierung

Stellen Sie mit Comparern alternative Sortierreihenfolgen bereit.

IComparer für benutzerdefinierte Sortierung ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Auf verschiedene Arten sortieren

Ein Typ hat über IComparable<T> nur eine natürliche Ordnung. Um dieselben Daten auf andere Weise zu sortieren, übergeben Sie an der Aufrufstelle einen IComparer<T> oder einen Comparison<T>-Delegate.

IComparer<T> implementieren

Ein IComparer<T> ist ein separates Objekt mit einer Compare(x, y)-Methode. Es folgt demselben Vertrag für negative, null und positive Werte wie 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));
    }
}

Mehrere Comparer für einen Typ

Sie können mehrere Comparer definieren und für jede Sortierung einen davon auswählen. Hier lassen sich dieselben Personen je nach Bedarf nach Namen oder Alter sortieren.

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

Für einmalige Sortierungen ist ein Comparison<T>-Delegate, häufig ein Lambda-Ausdruck, prägnanter als eine vollständige Klasse. List.Sort akzeptiert ihn direkt.

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

Absteigend mit einem Comparer

Kehren Sie eine Ordnung um, indem Sie die Operanden innerhalb von Compare vertauschen. So erhalten Sie eine absteigende Sortierung, ohne den Typ selbst zu ändern.

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

Comparer in OrderBy

LINQ-OrderBy akzeptiert als zweites Argument einen IComparer<TKey>. Dadurch können Sie festlegen, wie die ausgewählten Schlüssel verglichen werden.

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

Vergleich mehrerer Schlüssel

Ein Comparer kann nach mehreren Schlüsseln in Prioritätsreihenfolge sortieren. Berechnen Sie den ersten Schlüssel; bei Gleichstand fahren Sie mit dem nächsten fort.

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

Die Abkürzung Comparer.Create

Comparer<T>.Create erstellt aus einem Lambda ein IComparer<T>. Damit verbindet es die Prägnanz eines Delegates mit den Schnittstellen-APIs, die einen Comparer benötigen.

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

Comparer in mehreren Sammlungen wiederverwenden

Eine einzelne Comparer-Instanz kann Sortierungen, Suchen und sortierte Mengen steuern. Wenn Sie sie einmal definieren, bleiben die Ordnungsregeln überall konsistent, wo sie verwendet werden.

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 oder IComparer auswählen

Verwenden Sie IComparable<T> für die eine natürliche Ordnung, die im Typ selbst festgelegt ist. Verwenden Sie IComparer<T> oder Comparison<T> für die vielen alternativen, kontextabhängigen Ordnungen, die Sie an der Aufrufstelle festlegen.

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

Probieren Sie es selbst aus

Sortieren Sie eine Liste auf drei verschiedene Arten mit Comparern und einem Lambda-Ausdruck, ohne den Elementtyp anzupassen.

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

Kurzer Check

Wählen Sie die passende Abstraktion für die Ordnung.

Zusammenfassung

Benutzerdefinierte Sortierungen verwenden Comparer, die an der Aufrufstelle übergeben werden.

  • IComparer<T> implementiert Compare(x, y) mit dem Vertrag für negative, null und positive Werte.
  • Comparison<T>-Delegates und Lambdas eignen sich für einmalige Sortierungen.
  • Comparer<T>.Create verbindet Lambdas mit der Schnittstelle.
  • Verwenden Sie IComparable für die natürliche Ordnung und Comparer für alternative Ordnungen.

Häufig gestellte Fragen

Ist die Lektion „IComparer für benutzerdefinierte Sortierung“ kostenlos?

Ja — der vollständige Text von „IComparer für benutzerdefinierte Sortierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „IComparer für benutzerdefinierte Sortierung“?

Stellen Sie mit Comparern alternative Sortierreihenfolgen bereit. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „IComparer für benutzerdefinierte Sortierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. IEquatable implementieren
  2. GetHashCode überschreiben
  3. IComparable implementieren
  4. IComparer für benutzerdefinierte Sortierung
← Zurück zu C# Academy