Interfaces (Visual Basic)

Interfaces definiëren de eigenschappen, methoden en gebeurtenissen die klassen kunnen implementeren. Met interfaces kunt u functies definiëren als kleine groepen nauw verwante eigenschappen, methoden en gebeurtenissen; Dit vermindert compatibiliteitsproblemen omdat u verbeterde implementaties voor uw interfaces kunt ontwikkelen zonder bestaande code in gevaar te brengen. U kunt op elk gewenst moment nieuwe functies toevoegen door extra interfaces en implementaties te ontwikkelen.

Er zijn verschillende andere redenen waarom u mogelijk interfaces wilt gebruiken in plaats van klassenovername:

• Interfaces zijn beter geschikt voor situaties waarin uw toepassingen veel mogelijk niet-gerelateerde objecttypen vereisen om bepaalde functionaliteit te bieden.

• Interfaces zijn flexibeler dan basisklassen, omdat u één implementatie kunt definiëren die meerdere interfaces kan implementeren.

• Interfaces zijn beter in situaties waarin u de implementatie niet hoeft over te nemen van een basisklasse.

• Interfaces zijn handig wanneer u de overname van klassen niet kunt gebruiken. Structuren kunnen bijvoorbeeld niet worden overgenomen van klassen, maar ze kunnen interfaces implementeren.

Interfaces declareren

Interfacedefinities worden tussen de Interface en End Interface instructies ingesloten. Na de Interface instructie kunt u een optionele Inherits instructie toevoegen waarin een of meer overgenomen interfaces worden vermeld. De Inherits instructies moeten voorafgaan aan alle andere instructies in de declaratie, met uitzondering van opmerkingen. De resterende instructies in de interfacedefinitie moeten Eventzijn: , Sub, Function, Property, Interface, , , Classen StructureEnum instructies. Interfaces kunnen geen implementatiecode of instructies bevatten die zijn gekoppeld aan implementatiecode, zoals End Sub of End Property.

In een naamruimte zijn Friend interface-instructies standaard, maar ze kunnen ook expliciet worden gedeclareerd als Public of Friend. Interfaces die zijn gedefinieerd in klassen, modules, interfaces en structuren, zijn Public standaard, maar ze kunnen ook expliciet worden gedeclareerd als Public, Friendof PrivateProtected.

Notitie

Het Shadows trefwoord kan worden toegepast op alle interfaceleden. Het Overloads trefwoord kan worden toegepast op Sub, Functionen Property instructies die zijn gedeclareerd in een interfacedefinitie. Daarnaast Property kunnen instructies de Default, ReadOnlyof WriteOnly modifiers hebben. Geen van de andere modifiers( (Public , Private, Friend, Protected, Shared, , Overridesof OverridableMustOverride) zijn toegestaan. Zie Declaratiecontexten en standaardtoegangsniveaus voor meer informatie.

Met de volgende code wordt bijvoorbeeld een interface met één functie, één eigenschap en één gebeurtenis gedefinieerd.

Interface IAsset
    Event ComittedChange(ByVal Success As Boolean)
    Property Division() As String
    Function GetID() As Integer
End Interface

Interfaces implementeren

Het Visual Basic gereserveerde woord Implements wordt op twee manieren gebruikt. De Implements instructie geeft aan dat een klasse of structuur een interface implementeert. Het Implements trefwoord geeft aan dat een klasselid of structuurlid een specifiek interfacelid implementeert.

Implementeert instructie

Als een klasse of structuur een of meer interfaces implementeert, moet deze de Implements instructie direct na de Class of Structure instructie bevatten. Voor de Implements instructie moet een door komma's gescheiden lijst met interfaces worden geïmplementeerd door een klasse. De klasse of structuur moet alle interfaceleden implementeren met behulp van het Implements trefwoord.

Implementeert trefwoord

Voor het Implements trefwoord moet een door komma's gescheiden lijst met interfaceleden worden geïmplementeerd. Over het algemeen wordt slechts één interfacelid opgegeven, maar u kunt meerdere leden opgeven. De specificatie van een interfacelid bestaat uit de interfacenaam, die moet worden opgegeven in een implementatie-instructie binnen de klasse; een punt; en de naam van de lidfunctie, eigenschap of gebeurtenis die moet worden geïmplementeerd. De naam van een lid dat een interfacelid implementeert, kan elke juridische id gebruiken en is niet beperkt tot de InterfaceName_MethodName conventie die wordt gebruikt in eerdere versies van Visual Basic.

De volgende code laat bijvoorbeeld zien hoe u een subroutine met de naam Sub1 declareert waarmee een methode van een interface wordt geïmplementeerd:

Class Class1
    Implements interfaceclass.interface2

    Sub Sub1(ByVal i As Integer) Implements interfaceclass.interface2.Sub1
    End Sub
End Class

De parametertypen en retourtypen van het implementatielid moeten overeenkomen met de interface-eigenschap of liddeclaratie in de interface. De meest voorkomende manier om een element van een interface te implementeren, is met een lid dat dezelfde naam heeft als de interface, zoals wordt weergegeven in het vorige voorbeeld.

Als u de implementatie van een interfacemethode wilt declareren, kunt u alle kenmerken gebruiken die juridisch zijn voor instantiemethodedeclaraties, waaronder Overloads, , OverridableOverrides, ProtectedPrivateMustOverrideFriendProtected FriendPublic, en . DefaultStatic Het Shared kenmerk is niet legaal omdat het een klasse definieert in plaats van een instantiemethode.

Met behulp van Implementskunt u ook één methode schrijven waarmee meerdere methoden worden geïmplementeerd die zijn gedefinieerd in een interface, zoals in het volgende voorbeeld:

Class Class2
    Implements I1, I2

    Protected Sub M1() Implements I1.M1, I1.M2, I2.M3, I2.M4
    End Sub
End Class

U kunt een privélid gebruiken om een interfacelid te implementeren. Wanneer een privélid een lid van een interface implementeert, wordt dat lid beschikbaar via de interface, ook al is het niet rechtstreeks beschikbaar op objectvariabelen voor de klasse.

Voorbeelden van interface-implementatie

Klassen die een interface implementeren, moeten alle eigenschappen, methoden en gebeurtenissen ervan implementeren.

In het volgende voorbeeld worden twee interfaces gedefinieerd. De tweede interface, Interface2neemt een extra eigenschap en methode over Interface1 en definieert deze.

Interface Interface1
    Sub sub1(ByVal i As Integer)
End Interface

' Demonstrates interface inheritance.
Interface Interface2
    Inherits Interface1
    Sub M1(ByVal y As Integer)
    ReadOnly Property Num() As Integer
End Interface

In het volgende voorbeeld wordt de interface geïmplementeerd Interface1die in het vorige voorbeeld is gedefinieerd:

Public Class ImplementationClass1
    Implements Interface1
    Sub Sub1(ByVal i As Integer) Implements Interface1.sub1
        ' Insert code here to implement this method.
    End Sub
End Class

In het laatste voorbeeld wordt Interface2geïmplementeerd, inclusief een methode die is overgenomen van Interface1:

Public Class ImplementationClass2
    Implements Interface2
    Dim INum As Integer = 0
    Sub sub1(ByVal i As Integer) Implements Interface2.sub1
        ' Insert code here that implements this method.
    End Sub
    Sub M1(ByVal x As Integer) Implements Interface2.M1
        ' Insert code here to implement this method.
    End Sub

    ReadOnly Property Num() As Integer Implements Interface2.Num
        Get
            Num = INum
        End Get
    End Property
End Class

U kunt een alleen-lezeneigenschap implementeren met een eigenschap readwrite (dat wil zeggen dat u deze niet alleen-lezen hoeft te declareren in de implementatieklasse). Het implementeren van een interface belooft ten minste de leden te implementeren die door de interface worden aangegeven, maar u kunt meer functionaliteit bieden, zoals het mogelijk maken van uw eigenschap te beschrijfbaar zijn.

Verwante onderwerpen

Titel	Beschrijving
Overzicht: Interfaces maken en implementeren	Biedt een gedetailleerde procedure waarmee u uw eigen interface kunt definiëren en implementeren.
Afwijking in algemene interfaces	Beschrijft covariantie en contravariantie in algemene interfaces en biedt een lijst met variant-algemene interfaces in de .NET Framework.