C# Academy · Lektion

Generische Interfaces

Abstrahieren Sie über Typen.

Generische Interfaces 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.

Was ist ein generisches Interface?

Ein generisches Interface deklariert Typparameter in spitzen Klammern hinter seinem Namen. Implementierende Klassen wählen die konkreten Typen, und der Interfacevertrag passt sich entsprechend an.

Die .NET-Bibliothek verwendet generische Interfaces überall, zum Beispiel IEnumerable<T> und IComparable<T>.

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Ein generisches Interface implementieren

Eine Klasse kann ein generisches Interface implementieren, indem sie ein konkretes Typargument angibt. Die Methodensignaturen verwenden dann diesen tatsächlichen Typ.

So entsteht ein typsicherer und wiederverwendbarer Vertrag ohne Typumwandlungen.

using System.Collections.Generic;

class IntStore : IRepository<int>
{
    private readonly List<int> data = new();
    public void Add(int item) => data.Add(item);
    public int Get(int id) => data[id];
}

interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

Der Implementierungstyp bleibt generisch

Eine Klasse kann ein generisches Interface implementieren und dabei selbst generisch bleiben, indem sie ihren eigenen Typparameter an das Interface weitergibt.

So bleibt die Implementierung für jeden Elementtyp wiederverwendbar.

using System.Collections.Generic;

class Store<T> : IRepository<T>
{
    private readonly List<T> data = new();
    public void Add(T item) => data.Add(item);
    public T Get(int id) => data[id];
}

interface IRepository<T> { void Add(T item); T Get(int id); }

IComparable<T> in Aktion

IComparable<T> ist ein integriertes generisches Interface. Durch seine Implementierung kann Ihr Typ festlegen, wie Instanzen geordnet werden, und ermöglicht so das Sortieren.

Die Methode CompareTo gibt einen negativen Wert, null oder einen positiven Wert zurück.

class Money : IComparable<Money>
{
    public int Cents;
    public int CompareTo(Money? other)
        => Cents.CompareTo(other?.Cents ?? 0);
}

IEnumerable<T> implementieren

IEnumerable<T> bildet das Herzstück von LINQ und foreach. Ein Typ, der dieses Interface implementiert, kann durchlaufen werden. Häufig delegieren Sie an den Iterator einer inneren Collection.

Iterator-Methoden mit yield return machen dies einfach.

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

class Bag<T> : IEnumerable<T>
{
    private readonly List<T> items = new();
    public void Add(T x) => items.Add(x);
    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Ein ausführbares generisches Interface

Dieses vollständige Programm definiert ein generisches IPrinter<T>, implementiert es für Zeichenfolgen und verwendet es anschließend.

Das Interface garantiert unabhängig vom konkreten Typ eine Print-Methode.

using System;

interface IPrinter<T> { void Print(T value); }

class ConsolePrinter<T> : IPrinter<T>
{
    public void Print(T value) => Console.WriteLine(value);
}

class Program
{
    static void Main()
    {
        IPrinter<string> p = new ConsolePrinter<string>();
        p.Print("hello generics");
    }
}

Kovarianz mit out

Ein mit out markierter Parameter eines generischen Interfaces ist kovariant: Er erscheint ausschließlich an Ausgabepositionen. Dadurch kann IEnumerable<Cat> verwendet werden, wenn IEnumerable<Animal> erwartet wird.

Kovarianz erhält die Zuweisungskompatibilität entlang einer Vererbungshierarchie.

interface IProducer<out T>
{
    T Produce();
}

Kontravarianz mit in

Ein mit in markierter Parameter ist kontravariant: Er erscheint ausschließlich an Eingabepositionen. Dadurch kann ein IComparer<Animal> verwendet werden, wenn ein IComparer<Cat> erforderlich ist.

Kontravarianz kehrt bei Consumern die Richtung der Zuweisungskompatibilität um.

interface IConsumer<in T>
{
    void Consume(T item);
}

Mehrere Typparameter

Generische Schnittstellen können mehr als einen Parameter aufnehmen. IDictionary<TKey, TValue> ist ein bekanntes Beispiel mit getrennten Schlüssel- und Werttypen.

Jeder Parameter kann unabhängig invariant, kovariant oder kontravariant sein.

interface IMapper<TIn, TOut>
{
    TOut Map(TIn input);
}

Programmieren gegen die Schnittstelle

Wenn Sie von einer generischen Schnittstelle statt von einer konkreten Klasse abhängen, bleibt Ihr Code flexibel. Implementierungen lassen sich austauschen, ohne den aufrufenden Code zu ändern.

Methodenparameter mit dem Typ IEnumerable<T> akzeptieren gleichermaßen Listen, Arrays und Abfrageergebnisse.

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

int Total(IEnumerable<int> values) => values.Sum();

Einschränkungen mithilfe generischer Schnittstellen

Generische Schnittstellen werden häufig als Einschränkungen verwendet. where T : IComparable<T> ermöglicht es einer Methode, ihre Eingaben zu sortieren oder zu vergleichen.

Dadurch werden zwei Funktionen von Generics für sichere, wiederverwendbare Algorithmen kombiniert.

T Min<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) <= 0 ? a : b;

Schnelltest

Testen Sie Ihr Verständnis generischer Schnittstellen.

Zusammenfassung

Generische Schnittstellen deklarieren Typparameter und ermöglichen es Implementierern, diese festzulegen oder weiterzureichen. Zu den integrierten Beispielen gehören IEnumerable<T>, IComparable<T> und IDictionary<TKey, TValue>.

Varianzannotationen wie out und in ermöglichen Kovarianz und Kontravarianz. Außerdem lassen sich generische Schnittstellen gut mit where-Einschränkungen kombinieren.

Häufig gestellte Fragen

Ist die Lektion „Generische Interfaces“ kostenlos?

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

Abstrahieren Sie über Typen. 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 „Generische Interfaces“?

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

← Zurück zu C# Academy