0Pricing
C# Academy · Lektion

IEquatable implementieren

Stellen Sie mit Equals eine typsichere Gleichheit bereit.

IEquatable implementieren ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Warum IEquatable<T>?

IEquatable<T> stellt eine typsichere Equals(T other)-Methode bereit. Bei Werttypen wird dadurch Boxing vermieden, bei Referenztypen ein Cast. Dadurch wird Gleichheit sowohl schneller als auch klarer.

Implementieren des Interfaces

Implementieren Sie IEquatable<T> und stellen Sie Equals(T other) bereit. Sie sollten außerdem object.Equals und GetHashCode überschreiben, damit alle Wege konsistent bleiben.

using System;

public struct Point : IEquatable<Point>
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }

    public bool Equals(Point other) => X == other.X && Y == other.Y;
    public override bool Equals(object obj) => obj is Point p && Equals(p);
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Point(1, 2).Equals(new Point(1, 2)));
    }
}

Boxing bei Strukturen vermeiden

Die nicht generische Methode object.Equals(object) verpackt ein Strukturargument mittels Boxing. Die typisierte Methode Equals(Point other) aus IEquatable<T> übernimmt die Struktur direkt, sodass keine Allokation erfolgt.

using System;

public struct Point : IEquatable<Point>
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
    public bool Equals(Point other) => X == other.X && Y == other.Y; // no boxing
    public override bool Equals(object obj) => obj is Point p && Equals(p);
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

public class Program
{
    public static void Main()
    {
        Point a = new Point(3, 4);
        Point b = new Point(3, 4);
        Console.WriteLine(a.Equals(b)); // calls the typed overload
    }
}

Sammlungen verwenden IEquatable<T>

List<T>.Contains, Dictionary und HashSet bevorzugen IEquatable<T>.Equals, wenn es verfügbar ist. Durch die Implementierung werden diese Operationen für Ihren Typ effizient und korrekt.

using System;
using System.Collections.Generic;

public struct Point : IEquatable<Point>
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
    public bool Equals(Point other) => X == other.X && Y == other.Y;
    public override bool Equals(object obj) => obj is Point p && Equals(p);
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

public class Program
{
    public static void Main()
    {
        var list = new List<Point> { new Point(0, 0), new Point(1, 1) };
        Console.WriteLine(list.Contains(new Point(1, 1)));
    }
}

Referenztypen und IEquatable<T>

Auch Klassen können IEquatable<T> implementieren. Die typisierte Methode Equals vermeidet einen Cast, und Sie behandeln null für den Referenzparameter ausdrücklich.

using System;

public class Person : IEquatable<Person>
{
    public string Name;
    public Person(string name) { Name = name; }

    public bool Equals(Person other) => other != null && other.Name == Name;
    public override bool Equals(object obj) => Equals(obj as Person);
    public override int GetHashCode() => Name?.GetHashCode() ?? 0;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Person("Ada").Equals(new Person("Ada")));
        Console.WriteLine(new Person("Ada").Equals((Person)null));
    }
}

object.Equals über die typisierte Methode leiten

Ein sauberes Muster besteht darin, den Vergleich einmal in Equals(T) zu schreiben und object.Equals an diese Methode zu delegieren. Dadurch verhalten sich beide garantiert identisch.

using System;

public struct Id : IEquatable<Id>
{
    public int Value;
    public Id(int value) { Value = value; }
    public bool Equals(Id other) => Value == other.Value;
    public override bool Equals(object obj) => obj is Id other && Equals(other);
    public override int GetHashCode() => Value;
}

public class Program
{
    public static void Main()
    {
        object boxed = new Id(5);
        Console.WriteLine(boxed.Equals(new Id(5)));
    }
}

Mehrere Felder vergleichen

Bei Typen mit mehreren Feldern müssen Sie alle Felder in Equals vergleichen. Zwei Instanzen sind nur dann gleich, wenn jedes relevante Feld übereinstimmt.

using System;

public struct DateRange : IEquatable<DateRange>
{
    public int Start, End;
    public DateRange(int start, int end) { Start = start; End = end; }
    public bool Equals(DateRange other) => Start == other.Start && End == other.End;
    public override bool Equals(object obj) => obj is DateRange d && Equals(d);
    public override int GetHashCode() => HashCode.Combine(Start, End);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new DateRange(1, 5).Equals(new DateRange(1, 5)));
        Console.WriteLine(new DateRange(1, 5).Equals(new DateRange(1, 6)));
    }
}

Mit Operatoren kombinieren

Kombinieren Sie IEquatable<T> mit == und !=, damit Benutzende beide Schreibweisen zum Vergleichen verwenden können und beide auf demselben typisierten Vergleich beruhen.

using System;

public struct Money : IEquatable<Money>
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }
    public bool Equals(Money other) => Amount == other.Amount;
    public override bool Equals(object obj) => obj is Money m && Equals(m);
    public override int GetHashCode() => Amount.GetHashCode();
    public static bool operator ==(Money a, Money b) => a.Equals(b);
    public static bool operator !=(Money a, Money b) => !a.Equals(b);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Money(9.99m) == new Money(9.99m));
    }
}

Records implementieren es automatisch

Ein C#-record erzeugt für Sie IEquatable<T>, wertbasierte Equals- und GetHashCode-Implementierungen. Wenn Sie nur wertbasierte Gleichheit benötigen, erspart Ihnen ein Record viel wiederholten Code.

using System;

public record Point(int X, int Y);

public class Program
{
    public static void Main()
    {
        var a = new Point(1, 2);
        var b = new Point(1, 2);
        Console.WriteLine(a.Equals(b));
        Console.WriteLine(a == b);
    }
}

Wann eine manuelle Implementierung sinnvoll ist

Implementieren Sie IEquatable<T> manuell, wenn Sie benutzerdefinierte Gleichheitsregeln benötigen, etwa für Namen ohne Beachtung der Groß- und Kleinschreibung oder zum Ignorieren bestimmter Felder, die ein Record nicht direkt ausdrücken kann.

using System;

public class CaseInsensitiveTag : IEquatable<CaseInsensitiveTag>
{
    public string Name;
    public CaseInsensitiveTag(string name) { Name = name; }
    public bool Equals(CaseInsensitiveTag other)
        => other != null && string.Equals(Name, other.Name, StringComparison.OrdinalIgnoreCase);
    public override bool Equals(object obj) => Equals(obj as CaseInsensitiveTag);
    public override int GetHashCode() => Name?.ToLowerInvariant().GetHashCode() ?? 0;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new CaseInsensitiveTag("Red").Equals(new CaseInsensitiveTag("RED")));
    }
}

Probieren Sie es selbst aus

Implementieren Sie IEquatable<T> für einen kleinen Referenztyp und leiten Sie jeden Weg zum Vergleich über die typisierte Methode.

using System;
using System.Collections.Generic;

public class Coordinate : IEquatable<Coordinate>
{
    public int Lat, Lng;
    public Coordinate(int lat, int lng) { Lat = lat; Lng = lng; }
    public bool Equals(Coordinate other) => other != null && other.Lat == Lat && other.Lng == Lng;
    public override bool Equals(object obj) => Equals(obj as Coordinate);
    public override int GetHashCode() => HashCode.Combine(Lat, Lng);
}

public class Program
{
    public static void Main()
    {
        var set = new HashSet<Coordinate> { new Coordinate(10, 20) };
        Console.WriteLine(set.Contains(new Coordinate(10, 20)));
    }
}

Kurzer Test

Rufen Sie sich den Vorteil von IEquatable ins Gedächtnis.

Zusammenfassung

IEquatable<T> ermöglicht typsichere Gleichheit.

  • Stellt Equals(T other) bereit und vermeidet Boxing bei Strukturen sowie Casts bei Klassen.
  • Sammlungen bevorzugen es für korrekte und effiziente Suchvorgänge.
  • Leiten Sie object.Equals und Operatoren über die typisierte Methode.
  • Records implementieren es automatisch; für benutzerdefinierte Regeln implementieren Sie es manuell.

Häufig gestellte Fragen

Ist die Lektion „IEquatable implementieren“ kostenlos?

Ja — der vollständige Text von „IEquatable implementieren“ 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 „IEquatable implementieren“?

Stellen Sie mit Equals eine typsichere Gleichheit 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 1 von 4.

Wie lange dauert die Lektion „IEquatable implementieren“?

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