Koppelingen (Visual Basic)

2025-06-17

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 aanvullende interfaces en implementaties te ontwikkelen.

Er zijn verschillende andere redenen waarom u mogelijk interfaces wilt gebruiken in plaats van de overname van klassen:

Interfaces zijn beter geschikt voor situaties waarin uw toepassingen veel mogelijk niet-gerelateerde objecttypen nodig hebben 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 geen implementatie van een basisklasse hoeft over te nemen.
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 staan tussen de Interface en End Interface instructies. 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, behalve opmerkingen. De resterende instructies in de interfacedefinitie moeten Event, Sub, Function, Property, Interface, Class, Structure en Enum instructies zijn. 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 ProtectedPrivate.

Opmerking

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. Bovendien kunnen Property instructies de Default, ReadOnly of WriteOnly modificatoren hebben. Geen van de andere modifiers—Public, Private, Friend, Protected, Shared, Overrides, MustOverride, of Overridable—zijn toegestaan. Zie Declaratiecontexten en standaardtoegangsniveaus voor meer informatie.

De volgende code definieert bijvoorbeeld een interface met één functie, één eigenschap en één gebeurtenis.

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

Interfaces implementeren

Het gereserveerde woord Implements van Visual Basic 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 verklaring

Als een klasse of structuur een of meer interfaces implementeert, moet deze de Implements verklaring direct na de Class of Structure verklaring 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.

Trefwoord implementeren

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 implements-instructie binnen de klasse; een periode; 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 met dezelfde naam 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 declaraties van instantiemethoden, waaronder Overloads, Overrides, OverridablePublic, , Private, Protected, Friend, Protected Friend, MustOverride, en DefaultStatic. Het Shared kenmerk is niet legaal omdat er een klasse wordt gedefinieerd 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 in objectvariabelen voor de klasse.

Voorbeelden van interface-implementatie

Klassen die een interface implementeren, moeten alle eigenschappen, methoden en gebeurtenissen 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 Interface1de interface geïmplementeerd die is gedefinieerd in het vorige voorbeeld:

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 Interface2 geï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 tenminste de leden te implementeren die de interface declareert, maar u kunt meer functionaliteit bieden, zoals het mogelijk maken uw eigenschap beschrijfbaar te maken.

Titel	Beschrijving
Overzicht: Interfaces maken en implementeren	Biedt een gedetailleerde procedure die u door het proces van het definiëren en implementeren van uw eigen interface leidt.
Afwijking in algemene interfaces	Bespreekt covariantie en contravariantie in algemene interfaces en biedt een lijst met variant-algemene interfaces in .NET Framework.

Delen via