SchnittstellenInterfaces

Eine Schnittstelle definiert einen Vertrag, der von Klassen und Strukturen implementiert werden kann.An interface defines a contract that can be implemented by classes and structs. Eine Schnittstelle kann Methoden, Eigenschaften, Ereignisse und Indexer enthalten.An interface can contain methods, properties, events, and indexers. Eine Schnittstelle stellt keine Implementierungen der von ihr definierten Member bereit. Sie gibt lediglich die Member an, die von Klassen oder Strukturen bereitgestellt werden müssen, die die Schnittstelle implementieren.An interface does not provide implementations of the members it defines—it merely specifies the members that must be supplied by classes or structs that implement the interface.

Schnittstellen können Mehrfachvererbung einsetzen.Interfaces may employ multiple inheritance. Im folgenden Beispiel erbt die Schnittstelle IComboBox sowohl von ITextBox als auch IListBox.In the following example, the interface IComboBox inherits from both ITextBox and IListBox.

interface IControl
{
    void Paint();
}
interface ITextBox: IControl
{
    void SetText(string text);
}
interface IListBox: IControl
{
    void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {}

Klassen und Strukturen können mehrere Schnittstellen implementieren.Classes and structs can implement multiple interfaces. Im folgenden Beispiel implementiert die Klasse EditBox sowohl IControl als auch IDataBound.In the following example, the class EditBox implements both IControl and IDataBound.

interface IDataBound
{
    void Bind(Binder b);
}
public class EditBox: IControl, IDataBound
{
    public void Paint() { }
    public void Bind(Binder b) { }
} 

Wenn eine Klasse oder Struktur eine bestimmte Schnittstelle implementiert, können Instanzen dieser Klasse oder Struktur implizit in diesen Schnittstellentyp konvertiert werden.When a class or struct implements a particular interface, instances of that class or struct can be implicitly converted to that interface type. Beispiel:For example

EditBox editBox = new EditBox();
IControl control = editBox;
IDataBound dataBound = editBox;

In Fällen, in denen nicht bekannt ist, dass eine Instanz eine bestimmte Schnittstelle implementiert, können dynamische Typumwandlungen verwendet werden.In cases where an instance is not statically known to implement a particular interface, dynamic type casts can be used. Beispielsweise verwenden die folgenden Anweisungen dynamische Typumwandlungen zum Abrufen der IControl- und IDataBound-Schnittstellenimplementierungen eines Objekts.For example, the following statements use dynamic type casts to obtain an object’s IControl and IDataBound interface implementations. Da der eigentliche Laufzeittyp des Objekts EditBox ist, sind die Umwandlungen erfolgreich.Because the run-time actual type of the object is EditBox, the casts succeed.

object obj = new EditBox();
IControl control = (IControl)obj;
IDataBound dataBound = (IDataBound)obj;

In der vorherigen EditBox-Klasse werden die Paint-Methode aus der IControl-Schnittstelle und die Bind-Methode aus der IDataBound-Schnittstelle mithilfe öffentlicher Member implementiert.In the previous EditBox class, the Paint method from the IControl interface and the Bind method from the IDataBound interface are implemented using public members. C# unterstützt außerdem explizite Implementierungen eines Schnittstellenmembers, sodass die Klasse oder Struktur vermeiden können, die Member öffentlich zu machen.C# also supports explicit interface member implementations, enabling the class or struct to avoid making the members public. Eine explizite Implementierung eines Schnittstellenmembers wird mit dem vollqualifizierten Namen des Schnittstellenmembers geschrieben.An explicit interface member implementation is written using the fully qualified interface member name. Die EditBox-Klasse könnte z.B. die IControl.Paint- und IDataBound.Bind-Methode wie folgt über explizite Implementierungen eines Schnittstellenmembers implementieren.For example, the EditBox class could implement the IControl.Paint and IDataBound.Bind methods using explicit interface member implementations as follows.

public class EditBox: IControl, IDataBound
{
    void IControl.Paint() { }
    void IDataBound.Bind(Binder b) { }
}

Der Zugriff auf explizite Schnittstellenmember kann nur über den Schnittstellentyp erfolgen.Explicit interface members can only be accessed via the interface type. Die von der vorherigen EditBox-Klasse bereitgestellte Implementierung von IControl.Paint kann z.B. nur aufgerufen werden, indem zuerst der EditBox-Verweis in den IControl-Schnittstellentyp konvertiert wird.For example, the implementation of IControl.Paint provided by the previous EditBox class can only be invoked by first converting the EditBox reference to the IControl interface type.

EditBox editBox = new EditBox();
editBox.Paint();            // Error, no such method
IControl control = editBox;
control.Paint();            // Ok