Interface IComparer<T>

1. Einführung

Stell dir vor, du bist der Dekan einer Uni, an der eine riesige Menge Studierende eingeschrieben sind. Du brauchst regelmäßig Listen, die nach verschiedenen Kriterien sortiert sind:

1. Nach Name (damit du Studierende schnell alphabetisch findest).
2. Nach Durchschnittsnote (um Stipendien an die Besten zu vergeben).
3. Nach Alter (für Statistiken, Wettbewerbe usw.).
4. Nach Studienjahr, und innerhalb des Jahres nach Nachname.

Wenn wir uns nur auf IComparable<T> verlassen würden, müsste unsere Student-Klasse nur eine Vergleichslogik implementieren. Zum Beispiel könnten wir entscheiden, dass die "natürliche" Reihenfolge eines Studenten die nach Durchschnittsnote ist. Super, List.Sort() funktioniert jetzt! Aber was, wenn wir eine Liste nach Name sortiert brauchen? Die Student-Klasse ist schon mit dem Vergleich nach Note "belegt". Sie kann nicht zwei "natürliche" Ordnungen gleichzeitig haben. Das ist, als hättest du nur eine Anleitung "wie man der Beste im Boxen wird", aber plötzlich musst du im Schach gewinnen und versuchst, die Box-Anleitung zu benutzen. Wahrscheinlich klappt das nicht so gut, oder?

Genau für solche Fälle, wenn du denselben Objekttyp auf verschiedene Arten sortieren willst und die Vergleichslogik nicht in die Klasse selbst packen möchtest, gibt es das Interface IComparer<T>. Das ist praktisch, wenn du keinen Zugriff auf den Quellcode der Klasse hast oder die Klasse nicht alle Sortierarten kennen soll.

2. Interface IComparer<T>

Wenn IComparable<T> so etwas wie das innere Gefühl eines Objekts ist, also das Wissen, wie es sich selbst mit einem anderen vergleicht, dann ist IComparer<T> ein ganz anderer, externer Schiedsrichter oder unabhängiger Richter, der zwei beliebige Spieler (Objekte) nimmt und sie nach seinen eigenen, vorher festgelegten Regeln vergleicht.

Stell dir vor, du bist Trainer einer Fußballmannschaft. Du musst entscheiden, wer Kapitän wird.

• IComparable<T>: Jeder Spieler sagt selbst: "Ich bin besser als der Typ, weil ich schneller laufe!" (Seine eigene, interne Regel).
• IComparer<T>: Du als Trainer sagst: "Okay Leute, heute wählen wir den Kapitän nach Passgenauigkeit. Peter, spiel einen Pass! Max, spiel einen Pass! Super, Peter war genauer! Er ist heute Kapitän." (Das ist deine, externe Regel, die du auf beliebige zwei Spieler anwendest).

Definition: IComparer<T> ist ein Interface in .NET, das es uns erlaubt, externe Vergleichslogik für zwei Objekte vom Typ T zu definieren. Das heißt, die Klasse, die IComparer<T> implementiert, ist nicht eines der verglichenen Objekte; sie stellt einfach eine Compare-Methode bereit, die zwei Objekte nimmt und deren relative Reihenfolge bestimmt.

Syntax

Die Syntax von IComparer<T> ist ziemlich simpel:

public interface IComparer<T>
{
    // Methode, die zwei Objekte vom Typ T vergleicht
    // x - erstes Objekt zum Vergleichen
    // y - zweites Objekt zum Vergleichen
    int Compare(T x, T y);
}

Die Methode Compare(T x, T y) funktioniert genauso wie CompareTo(T other) in IComparable<T>:

• Gibt eine negative Zahl zurück, wenn x "kleiner" als y ist.
• Gibt null (0) zurück, wenn x "gleich" y ist.
• Gibt eine positive Zahl zurück, wenn x "größer" als y ist.

In unserem Fall hängen "kleiner", "gleich", "größer" nur von unserer Vergleichslogik ab, die wir in der Compare-Implementierung festlegen.

Was ist der Unterschied zwischen IComparer<T> und IComparable<T>?

IComparable<T>

IComparer<T>

3. IComparer<T> in der Praxis implementieren

Lass uns unser "großes Beispielprojekt" weiterentwickeln – ein einfaches User-Modell. Angenommen, wir haben diese Klasse:

// Unsere User-Klasse
public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Email { get; set; }
}

Sortierung nach Name: eigenen Comparer bauen

Wir schreiben eine spezielle Klasse, die IComparer<User> implementiert und User nach Name vergleicht:

// Comparer-Klasse für Sortierung nach Name
public class UserNameComparer : IComparer<User>
{
    public int Compare(User x, User y)
    {
        // Auf null prüfen (damit es keine Überraschungen gibt!)
        if (ReferenceEquals(x, y)) return 0;
        if (x is null) return -1;   // null ist "kleiner" als jedes Objekt
        if (y is null) return 1;

        // Nach Name vergleichen (unter Berücksichtigung der String-Sortierung)
        return string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
    }
}

Comparer zum Sortieren einer Liste verwenden:

List<User> users = new List<User>
{
    new User { Name = "Ivan", Age = 20, Email = "ivan@mail.com" },
    new User { Name = "Anna", Age = 32, Email = "anna@gmail.com" },
    new User { Name = "Boris", Age = 28, Email = "boris@work.org" },
    new User { Name = "Ruslan", Age = 19, Email = "ruslan@yandex.ru" }
};

// Nach Name mit IComparer sortieren
users.Sort(new UserNameComparer());

users.ForEach(u => Console.WriteLine(u.Name)); // Anna, Boris, Ivan, Ruslan

Siehst du, wie elegant das ist? Die Comparer-Klasse ist ein eigenständiger Bürger in deinem Programm – du kannst sie für beliebige andere User-Listen wiederverwenden.

4. Mehrere Vergleichsarten: verschiedene Comparer bauen

Cool ist, dass du so viele Comparer bauen kannst, wie du willst. Zum Beispiel, lass uns nach Alter sortieren:

// Comparer für Sortierung nach Alter
public class UserAgeComparer : IComparer<User>
{
    public int Compare(User x, User y)
    {
        if (ReferenceEquals(x, y)) return 0;
        if (x is null) return -1;
        if (y is null) return 1;

        // Nach Alter aufsteigend sortieren
        return x.Age.CompareTo(y.Age);
    }
}

Und jetzt:

users.Sort(new UserAgeComparer());
users.ForEach(u => Console.WriteLine($"{u.Name} ({u.Age})"));
// Ausgabe: Ruslan (19) Ivan (20) Boris (28) Anna (32)

Wenn du nach Alter absteigend sortieren willst, kannst du einfach die Argumente tauschen:

// Comparer für Sortierung nach absteigendem Alter
public class UserAgeDescendingComparer : IComparer<User>
{
    public int Compare(User x, User y)
    {
        if (ReferenceEquals(x, y)) return 0;
        if (x is null) return -1;
        if (y is null) return 1;

        // Reihenfolge umdrehen: y.CompareTo(x)
        return y.Age.CompareTo(x.Age);
    }
}

5. Nützliche Details

Wie funktioniert das intern?

Wenn du Sort() mit einem Comparer aufrufst, gibt die Liste jedes Element an den Comparer und fragt: "Wen soll ich zuerst nehmen?". Deine Compare-Methode antwortet: "den, den oder egal". Die Sortierung wiederholt diesen Dialog für alle Paare, bis die finale, sortierte Liste steht.

Was tun, wenn die Werte gleich sind? Einfach 0 zurückgeben – das heißt, die Reihenfolge bleibt (oder wird vom internen Sortiermechanismus entschieden).

Wo wird IComparer<T> noch verwendet?

Das Interface IComparer<T> wird nicht nur in Listen genutzt. Hier ein paar Beispiele, wo es in .NET auftaucht:

• In Konstruktoren von Collections wie SortedList<TKey, TValue> und SortedSet<T>: Du musst eine Reihenfolge der Elemente angeben.
• Für Suchen mit BinarySearch.

Hier ein Beispiel:

var sortedSet = new SortedSet<User>(new UserAgeComparer());

Jetzt hält SortedSet die Reihenfolge immer automatisch nach Alter!

Kurz zu null-Sicherheit

Einer der häufigsten Fehler bei Anfängern ist NullReferenceException. Vergiss nicht, in Compare auf null zu prüfen, besonders wenn die Liste solche Werte enthalten kann.

Typisches Pattern (hier nochmal, damit du es dir merkst):

if (ReferenceEquals(x, y)) return 0;
if (x is null) return -1;
if (y is null) return 1;

Das ist eine gute Angewohnheit: Sie hilft, Abstürze im dümmsten Moment zu vermeiden!

Vorteile und Einschränkungen des IComparer<T>-Ansatzes

• Du trennst Vergleichslogik klar von den Daten. Die User-Klasse muss sich nicht darum kümmern, wie und warum sie sortiert wird.
• Vergleichslogik ist easy wiederverwendbar.
• Skalierbarkeit: Du kannst beliebig viele Sortierarten bauen, ohne den Originaltyp zu ändern.

Aber sei vorsichtig, damit du nicht in die Falle "null vergessen" oder "Vergleichslogik nicht konsistent" tappst. Zum Beispiel: Wenn Compare(x, y) 0 zurückgibt, muss Compare(y, x) auch 0 liefern; wenn Compare(x, y) >0 ist, muss Compare(y, x) <0 sein usw.

Visuelle Merkhilfe: Wann was benutzen?

IComparable<T>

IComparer<T>

Comparison<T>

IComparer<T>

In der nächsten Vorlesung lernst du, wie du Delegates und Lambda-Ausdrücke zum Vergleichen von Objekten nutzt und kombinierst. Probier bis dahin, für deine App ein paar verschiedene Comparer zu bauen und genieße die elegante Architektur, bei der die Sortierung außerhalb der Hauptklasse passiert und die Auswahl des Kriteriums flexibel und erweiterbar bleibt.

6. Typische Fehler bei der Comparer-Implementierung

Fehler Nr. 1: Keine Prüfung auf null.
Wenn eines der verglichenen Objekte null ist und du das nicht im Code abfängst, kann das Programm mit NullReferenceException abstürzen.

Fehler Nr. 2: Falsche Werte für -1, 0, +1.
Die Compare-Methode muss eine negative Zahl zurückgeben, wenn das erste Objekt kleiner ist, null wenn sie gleich sind, und eine positive wenn es größer ist. Wenn du das nicht beachtest, funktioniert die Sortierung "komisch".

Fehler Nr. 3: Asymmetrische Vergleichslogik.
Wenn du beim Vergleich von x und y etwas anderes zurückgibst als beim Vergleich von y und x (statt dem entgegengesetzten Wert), wird das Ergebnis unvorhersehbar.

Fehler Nr. 4: Sort() ohne Comparer für einen eigenen Typ verwenden.
Wenn der Typ nicht IComparable oder IComparable<T> implementiert, führt ein Aufruf von Sort() ohne expliziten Comparer zu einer InvalidOperationException.

Wie vermeiden:
Teste Grenzfälle, schreib Unit-Tests für kritische Codestellen (dazu kommen wir noch!), schau ruhig mal in die Doku – und lass deine Comparer wie Schweizer Uhren laufen.

2

Aufgabe

C# SELF, Level 30, Lektion 1

Gesperrt

Implementierung eines Komparators für Strings

Implementierung eines Komparators für Strings

Öffnen