Tracks
/
C#
C#
/
Lehrplan
/
Schnittstellen
Sc

Schnittstellen in C#

2 Übungen

Über Schnittstellen

interfaces sind das wichtigste Mittel, um die Verwendung einer Klasse von ihrer Implementierung zu entkoppeln. Diese Entkopplung gibt dir Flexibilität bei der Pflege der Implementierung und unterstützt typsicheres generisches Verhalten.

Die Syntax eines Interface ähnelt der einer Klasse oder eines Structs, mit dem Unterschied, dass Methoden und Eigenschaften nur als Signatur auftreten und kein Rumpf angegeben wird.

public interface ILanguage
{
    string Speak();
}

public interface IItalianLanguage : ILanguage
{
    string Speak();
    string SpeakItalian();
}

public interface IScriptConverter
{
    string Version { get; set; }
    string ConvertCyrillicToLatin(string cyrillic);
}

Die implementierende Klasse oder das implementierende Struct muss alle Operationen implementieren, die das Interface definiert.

Interfaces erfüllen typischerweise eine oder mehrere der folgenden Aufgaben:

  • Sie ermöglichen es, dass eine Reihe verschiedener Klassen vom verwendenden Code generisch behandelt werden. In diesem Fall spielen Interfaces dieselbe Rolle wie eine Basisklasse.
  • Sie legen eine Teilmenge der Funktionalität für einen bestimmten Zweck offen (etwa IComparable<T>), oder
  • Sie legen die öffentliche API einer Klasse offen, damit mehrere Implementierungen nebeneinander existieren können. Ein Beispiel dafür ist ein Test Double.
public class ItalianTraveller : IItalianLanguage
{
    public string Speak()
    {
        return "Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class ItalianTravellerV2 : IItalianLanguage
{
    public string Speak()
    {
        return "migliorata - Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class FrenchTraveller : ILanguage
{
    public string Speak()
    {
        return "Ça va?";
    }
}

public class RussianTraveller : ILanguage, IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Speak()
    {
        return "Привет мир";
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

public class DocumentTranslator : IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Translate(string russian)
    {
        throw new NotImplementedException();
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

Code, der die oben genannten Interfaces und Klassen verwendet, kann:

  • alle Sprecher unabhängig von ihrer Sprache gleich behandeln.
  • einem Subsystem, das die Skriptkonvertierung übernimmt, erlauben zu arbeiten, ohne sich darum zu kümmern, mit welchen konkreten Typen es zu tun hat.
  • von Änderungen am italienischen Sprecher nichts mitbekommen, was praktisch ist, wenn Klassencode und Nutzercode von verschiedenen Teams gepflegt werden.

Interfaces werden häufig eingesetzt, um Tests zu unterstützen, weil sie einfaches Mocking ermöglichen.

In diesem Artikel erfährst du, welche Arten von Membern ein Interface enthalten kann.

Interfaces können von anderen Interfaces erben.

Member eines Interface sind standardmäßig öffentlich.

Interfaces können verschachtelte Typen enthalten, etwa const-Literale, enums, delegates, classes und structs. Hier wirken die Interfaces wie Namespaces, genauso wie Klassen und Structs, und Verhalten und Syntax sind identisch.

C# unterstützt von Haus aus keine Mehrfachvererbung, ermöglicht aber über Interfaces eine Art von Mehrfachvererbung.

Außerdem bildet das Konzept, dass Polymorphismus über Interfaces umgesetzt werden kann, die Grundlage des Interface-Mechanismus.

Explizite Interface-Implementierung

Manchmal haben Methoden in zwei verschiedenen Interfaces denselben Namen und dieselbe Signatur. Um diese Methoden getrennt implementieren zu können, bietet C# die explizite Implementierung von Interfaces. Beachte: Um eine bestimmte Implementierung eines Interface zu verwenden, musst du den Ausdruck, der auf das Objekt verweist, in dieses Interface umwandeln. Eine Zuweisung, ein Cast oder die Übergabe als Parameter erreichen das.

public interface IFoo
{
    void X();
}

public interface IBar
{
    void X();
}

public class Census : IFoo, IBar
{
    void IFoo.X()
    {
        Console.Write("This is from Foo");
    }

    void IBar.X()
    {
        Console.Write("This is from Bar");
    }
}

public class User
{
    public void Use()
    {
        IFoo foo = new Census();
        IBar bar = new Census();
        foo.X();
        // => "This is from Foo"
        bar.X();
        // => "This is from Bar"
    }
}

Es gibt eine Reihe von Anwendungsfällen:

  • Eine Kollision von Domänen (wie oben dargestellt), bei der Methoden identische Signaturen haben.
  • Methoden mit demselben Namen, aber unterschiedlichen Rückgabetypen: Wenn du eigene Collection-Klassen implementierst, kann es sein, dass du ein explizites Interface für das veraltete IEnumerable.GetEnumerator() neben IEnumerable<T>.GetEnuerator() brauchst. Vielleicht nutzt du dieses Interface nie, aber der Compiler besteht möglicherweise darauf.
  • Methoden, bei denen es keinen Namenskonflikt zwischen den Interfaces gibt, die implementierende Klasse den Namen aber für einen verwandten Zweck nutzen soll: IFormattable hat eine ToString()-Methode, die neben einem Parameter vom Typ IFormatProvider auch einen Formattyp-Parameter entgegennimmt. Eine Klasse wie FormattableString aus der Base Class Library (BCL) implementiert das Interface, damit sie von Routinen verwendet werden kann, die ein IFormattable erwarten. Für ihre Hauptversion von ToString(IFormatProvider) ist es jedoch ausdrucksstärker, den Formattyp-Parameter wegzulassen, weil er in der Implementierung nicht verwendet wird und die Nutzer der API nur verwirren würde.

Standardimplementierung

Version 8 von C# geht ein lästiges Problem mit APIs an. Wenn du einem Interface Methoden hinzufügst, um neue Implementierungen mit zusätzlicher Funktionalität zu versorgen, musst du alle bestehenden Implementierungen des Interface anpassen, damit sie den API-Vertrag erfüllen, obwohl sie gar kein implementationsspezifisches Verhalten haben. C# erlaubt es jetzt, eine Standardmethode als Teil des Interface bereitzustellen (Java-Entwickler kennen das). Früher gab es bei einer solchen Änderung neben dem ursprünglichen Interface eine Version 2 davon.

Dieser Artikel ist eine hervorragende Einführung in Interfaces und behandelt vor allem die Standardimplementierung sowie weitere unterstützende Neuerungen wie static-, private- und virtual-Member.

Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab

Lerne Schnittstellen

Das Üben ist gesperrt

Schalte 1 weitere Übung frei, um Schnittstellen zu üben