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:
IComparable<T>), oderpublic 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:
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.
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:
IEnumerable.GetEnumerator() neben IEnumerable<T>.GetEnuerator() brauchst. Vielleicht nutzt du dieses Interface nie, aber der Compiler besteht möglicherweise darauf.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.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.