Exemplarische Vorgehensweise: Erstellen und Implementieren von Schnittstellen (Visual Basic)

Artikel
06/08/2015

Schnittstellen beschreiben die Merkmale von Feldern, Eigenschaften, Methoden und Ereignissen, wobei die Einzelheiten der Implementierung in Strukturen oder Klassen definiert sind.

Diese exemplarische Vorgehensweise veranschaulicht das Deklarieren und Implementieren einer Schnittstelle.

Hinweis

Diese exemplarische Vorgehensweise bietet keine Informationen dazu, wie eine Benutzeroberfläche erstellt wird.

Hinweis

Auf Ihrem Computer werden möglicherweise andere Namen oder Speicherorte für die Benutzeroberflächenelemente von Visual Studio angezeigt als die in den folgenden Anweisungen aufgeführten. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Anpassen der Entwicklungseinstellungen in Visual Studio.

So definieren Sie eine Schnittstelle

Öffnen Sie ein neues Visual Basic-Windows-Anwendungsprojekt.
Fügen Sie dem Projekt ein neues Modul hinzu, indem Sie im Menü Projekt auf Modul hinzufügen klicken.
Benennen Sie das neue Modul Module1.vb, und klicken Sie auf Hinzufügen. Der Code für das neue Modul wird angezeigt.
Definieren Sie in Module1 die TestInterface-Schnittstelle, indem Sie Interface TestInterface zwischen der Module-Anweisung und der End Module-Anweisung eingeben und dann die EINGABETASTE drücken. Der Code-Editor rückt das Interface-Schlüsselwort ein und fügt eine End Interface-Anweisung hinzu, um einen Codeblock zu bilden.
Definieren Sie eine Eigenschaft, eine Methode und ein Ereignis für die Schnittstelle, indem Sie zwischen der Interface-Anweisung und der End Interface-Anweisung folgenden Code einfügen:
```
Property Prop1() As Integer 
Sub Method1(ByVal X As Integer)
Event Event1()
```

Implementierung

Die Syntax für das Deklarieren von Schnittstellenmembern unterscheidet sich von der Syntax für das Deklarieren von Klassenmembern. Die Ursache für diesen Unterschied ist, dass Schnittstellen keinen Implementierungscode enthalten können.

So implementieren Sie die Schnittstelle

Fügen Sie eine Klasse mit dem Namen ImplementationClass hinzu, indem Sie in Module1 nach der End Interface-Anweisung und vor der End Module-Anweisung die folgende Anweisung einfügen und dann die EINGABETASTE drücken:
```
Class ImplementationClass
```
Wenn Sie in der IDE (Integrated Development Environment) arbeiten, stellt der Code-Editor eine entsprechende End Class-Anweisung bereit, sobald Sie die EINGABETASTE drücken.
Fügen Sie ImplementationClass die folgende Implements-Anweisung hinzu, die die von der Klasse implementierte Schnittstelle benennt:
```
Implements TestInterface
```
Wenn die Implements-Anweisung getrennt von anderen Elementen am Anfang einer Klasse oder Struktur steht, gibt sie an, dass die Klasse bzw. Struktur eine Schnittstelle implementiert.

Wenn Sie in der IDE (Integrated Development Environment) arbeiten, implementiert der Code-Editor die für TestInterface erforderlichen Klassenmember, sobald Sie die EINGABETASTE drücken. Der nächste Schritt wird dadurch übersprungen.
Wenn Sie nicht innerhalb der integrierten Entwicklungsumgebung arbeiten, müssen Sie alle Member der MyInterface-Schnittstelle implementieren. Fügen Sie ImplementationClass folgenden Code hinzu, um Event1, Method1 und Prop1 zu implementieren.
```
Event Event1() Implements TestInterface.Event1

Public Sub Method1(ByVal X As Integer) Implements TestInterface.Method1
End Sub 

Public Property Prop1() As Integer Implements TestInterface.Prop1
    Get 
    End Get 
    Set(ByVal value As Integer)
    End Set 
End Property
```
Die Implements-Anweisung benennt die Schnittstelle und den Schnittstellenmember, der implementiert wird.
Vervollständigen Sie die Definition von Prop1, indem Sie der Klasse, in der der Eigenschaftswert gespeichert wurde, ein privates Feld hinzufügen:
```
' Holds the value of the property. 
Private pval As Integer
```
Geben Sie den Wert von pval aus dem get-Accessor der Eigenschaft zurück.
```
Return pval
```
Legen Sie den Wert von pval im set-Accessor der Eigenschaft fest.
```
pval = value
```
Vervollständigen Sie die Definition von Method1, indem Sie folgenden Code hinzufügen.
```
MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()
```

So testen Sie die Implementierung der Schnittstelle

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Startformular des Projekts, und klicken Sie dann auf Code anzeigen. Im Editor wird die Klasse des Startformulars angezeigt. In der Standardeinstellung wird das Startformular mit Form1 bezeichnet.
Fügen Sie der Form1-Klasse das folgende testInstance-Feld hinzu:
```
Dim WithEvents testInstance As TestInterface
```
Wenn testInstance als WithEvents deklariert wird, kann die Form1-Klasse seine Ereignisse behandeln.
Fügen Sie der Form1-Klasse folgenden Ereignishandler hinzu, um durch testInstance ausgelöste Ereignisse zu behandeln:
```
Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub
```

Fügen Sie der Form1-Klasse eine Unterroutine mit dem Namen Test hinzu, um die Implementierungsklasse zu testen:

Sub Test()
    '  Create an instance of the class. 
    Dim T As New ImplementationClass
    ' Assign the class instance to the interface. 
    ' Calls to the interface members are  
    ' executed through the class instance.
    testInstance = T
    ' Set a property.
    testInstance.Prop1 = 9
    ' Read the property.
    MsgBox("Prop1 was set to " & testInstance.Prop1)
    '  Test the method and raise an event.
    testInstance.Method1(5)
End Sub

Die Test-Prozedur erstellt eine Instanz der Klasse, die MyInterface implementiert, weist diese Instanz dem testInstance-Feld zu, legt eine Eigenschaft fest und führt eine Methode über die Schnittstelle aus.

Fügen Sie Code ein, um die Test-Prozedur aus der Form1 Load-Prozedur des Startformulars heraus aufzurufen:

Private Sub Form1_Load(ByVal sender As System.Object, 
                       ByVal e As System.EventArgs) Handles MyBase.Load
    Test() ' Test the class.
End Sub

Führen Sie die Test-Prozedur aus, indem Sie F5 drücken. Die Meldung "Prop1 was set to 9" wird angezeigt. Nachdem Sie auf OK geklickt haben, wird die Meldung "The X parameter for Method1 is 5" angezeigt. Klicken Sie auf OK. Daraufhin wird die Meldung "The event handler caught the event" angezeigt.