Genomgång: Skapa och implementera gränssnitt (Visual Basic)

Gränssnitt beskriver egenskaperna för egenskaper, metoder och händelser, men lämnar implementeringsinformationen upp till strukturer eller klasser.

Den här genomgången visar hur du deklarerar och implementerar ett gränssnitt.

Anmärkning

Den här genomgången innehåller inte information om hur du skapar ett användargränssnitt.

Anmärkning

Datorn kan visa olika namn eller platser för vissa av Visual Studio-användargränssnittselementen i följande instruktioner. Den Visual Studio-utgåva som du har och de inställningar som du använder avgör dessa element. Mer information finns i Anpassning av utvecklingsmiljön.

Så här definierar du ett gränssnitt

Öppna ett nytt Visual Basic Windows-programprojekt.
Lägg till en ny modul i projektet genom att klicka på Lägg till modul på Projekt-menyn .
Ge den nya modulen Module1.vb namnet och klicka på Lägg till. Koden för den nya modulen visas.
Definiera ett gränssnitt med namnet TestInterface inom Module1 genom att skriva Interface TestInterface mellan Module och End Module-uttrycken och sedan trycka på RETUR. Kodredigeraren drar in nyckelordet Interface och lägger till en End Interface instruktion för att skapa ett kodblock.
Definiera en egenskap, metod och händelse för gränssnittet genom att placera följande kod mellan - och-uttrycken InterfaceEnd Interface :
```
Property Prop1() As Integer
Sub Method1(ByVal X As Integer)
Event Event1()
```

Genomförande

Du kanske märker att syntaxen som används för att deklarera gränssnittsmedlemmar skiljer sig från den syntax som används för att deklarera klassmedlemmar. Den här skillnaden återspeglar det faktum att gränssnitt inte kan innehålla implementeringskod.

Implementera gränssnittet

Lägg till en klass med namnet ImplementationClass genom att lägga till följande -instruktion i Module1, efter -instruktionen End Interface men före -instruktionen End Module och tryck sedan på RETUR:
```
Class ImplementationClass
```
Om du arbetar i den integrerade utvecklingsmiljön tillhandahåller kodredigeraren en matchande End Class instruktion när du trycker på RETUR.
Lägg till följande Implements instruktion i ImplementationClass, som namnger gränssnittet som klassen implementerar:
```
Implements TestInterface
```
När instruktionen visas separat från andra objekt överst i en klass eller struktur anger den Implements att klassen eller strukturen implementerar ett gränssnitt.

Om du arbetar i den integrerade utvecklingsmiljön implementerar kodredigeraren de klassmedlemmar som krävs när TestInterface du trycker på RETUR, och du kan hoppa över nästa steg.
Om du inte arbetar i den integrerade utvecklingsmiljön måste du implementera alla medlemmar i gränssnittet MyInterface. Lägg till följande kod ImplementationClass för att implementera Event1, Method1 och Prop1.
```
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
```
Uttalandet Implements namnger gränssnittet och gränssnittsmedlemmen som implementeras.
Slutför definitionen av Prop1 genom att lägga till ett privat fält i klassen som lagrade egenskapsvärdet:
```
' Holds the value of the property.
Private pval As Integer
```
Returnera värdet för pval från egenskapen hämta accessor.
```
Return pval
```
Ange värdet av pval i egenskapsinställningsmetoden.
```
pval = value
```

Slutför definitionen av Method1 genom att lägga till följande kod.

MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()

Testa implementeringen av gränssnittet

Högerklicka på startformuläret för projektet i Solution Explorer och klicka på Visa kod. Redigeraren visar klassen för startformuläret. Startformuläret kallas Form1som standard .
Lägg till följande testInstance fält i Form1 klassen:
```
Dim WithEvents testInstance As TestInterface
```
Genom att testInstance deklarera som WithEventskan Form1 klassen hantera sina händelser.
Lägg till följande händelsehanterare i Form1 klassen för att hantera händelser som genereras av testInstance:
```
Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub
```

Lägg till en underrutin med namnet Test i Form1 klassen för att testa implementeringsklassen:

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

Proceduren Test skapar en instans av klassen som implementerar MyInterface, tilldelar instansen testInstance till fältet, anger en egenskap och kör en metod via gränssnittet.

Lägg till kod för att anropa proceduren Test från proceduren i startformuläret Form1 Load :

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

Kör proceduren Test genom att trycka på F5. Meddelandet "Prop1 har angetts till 9" visas. När du har klickat på OK visas meddelandet "X-parametern för Metod1 är 5". Klicka på OK så visas meddelandet "Händelsehanteraren fångade händelsen".

Se även

Feedback

Var den här sidan till hjälp?

Last updated on 2025-06-17