welk verschil een jaar of twee kan opleveren. Twee en een half jaar geleden dacht ik dat ik zou het schrijven van een boek met de titel Visual Basic 7 Unleashed voor Sams. Het voltooien van de laatste concepten van Sams Visual Basic.NET Unleashed herinnert me eraan dat er veel is veranderd in Visual Basic.
om u te helpen de overgang zo grondig en volledig mogelijk te maken, schrijven ikzelf en andere auteurs en medewerkers veel over threading, reflectie, assemblies, COM interop en gedelegeerden. Maar toen ik onlangs programmeeronderwerpen met een vriend bekeek, werd ik eraan herinnerd dat er ontwikkelaars zijn op alle niveaus, niet alleen op het gevorderde niveau. Om zo grondig mogelijk te zijn, onderzoek ik zowel geavanceerde als niet-geavanceerde onderwerpen. (Ik ben ook blij met vragen van Lezers, en soms schrijf ik een artikel op basis van verschillende vragen.)
dit artikel is to the point. In dit artikel zullen we interfaces onderzoeken: hoe ze te definiëren en hoe ze te implementeren.
het idee van een interface is niet nieuw voor COM, maar in Visual Basic 6 was elke klasse een COM-interface. In Visual Basic .NET elke klasse is een klasse en een interface is een interface, maar niet een COM-interface. Klassen bestaan al tientallen jaren en interfaces zijn niet de enige bevoegdheid van COM. Een klasse beschrijft de velden, eigenschappen, gebeurtenissen en methoden die een type zal hebben. Een interface is meer een portaal of een bijlage. Een interface zegt dat een type deze specifieke methoden zal implementeren, maar geeft niet aan wat een type is. Een huis kan bijvoorbeeld een raam hebben, maar een auto ook. Een type dat een methode open implementeert kan worden gedefinieerd als iets dat een raam heeft, maar de types kunnen auto ‘ s, boten, huizen of de ziel definiëren.Visual Basic 6 ondersteunt geen overerving of klassen in de objectgeoriënteerde zin van de constructie. VB6 ondersteunt COM-interfaces. VB. NET, anderzijds ondersteunt klassen en interfaces, dus een onderscheid moest worden gemaakt tussen de twee idiomen.
klassen en Interfaces definiëren in VB. NET
de klasse-en interfacetalen gebruiken een zeer vergelijkbare syntaxis wanneer u ze definieert. Het volgende voorbeeld definieert een lege klasse in VB. NET, gevolgd door een lege interface.
Public Class AClassEnd ClassPublic Interface AnInterfaceEnd Interface
klassen kunnen velden, eigenschappen, gebeurtenissen en methoden bevatten. Deze elementen van een klasse, die leden worden genoemd, kunnen modifiers hebben die aangeven dat ze publiek, privé, beschermd of vriend zijn. Alle leden van een interface declaratie zijn openbaar en als gevolg daarvan hebben ze geen toegangsmodifiers nodig of kunnen ze deze ook niet hebben.
klassen bevatten code; interfaces niet. Klassen die een interface implementeren bevatten echter wel code. Houd er rekening mee dat er geen gevallen van interfaces in VB. NET. Elke instantie is een type dat een interface implementeert, maar is zelf geen instantie van de interface. (Vanaf dit punt zullen we de bespreking van de klassen voor een andere tijd te verlaten en richten zich alleen op interfaces.)
interfaces implementeren
aangenomen dat we een interface hebben met de naam AnInterface, kunnen we alleen methodedeclaraties aan die interface toevoegen. Uitbreiding van de interface van de vorige sectie, kunnen we een methode genaamd WhoAmI toe te voegen. Het resultaat wordt hierna getoond.
Public Interface AnInterface Function WhoAmI() As StringEnd Interface
alle typen die de AnInterface-interface implementeren, moeten elke gedeclareerde methode in die interface implementeren. In dit voorbeeld hoeven we alleen de functie WhoAmI te implementeren. Stel dat AClass eeninterface implementeert; we zouden WhoAmI moeten implementeren. Het resultaat van het implementeren van Eeninterface in AClass zou de volgende code opleveren.
Public Class AClass Implements AnInterface Public Function WhoAmI() As String Implements AnInterface.WhoAmI Return "AClass" End FunctionEnd Class
het eerste wat we moeten doen is aangeven dat we de interface op naam willen implementeren. Implements AnInterface vertelt consumenten dat AClass alle in Eeninterface beschreven methoden zal implementeren. (De Visual Studio. NET IDE herinnert ons eraan dat we dat ook moeten doen.)
het verschil tussen VB6 en VB .NET is dat we de Implements clausule moeten toevoegen aan het functielichaam zoals getoond in de lijst. De functie wordt als normaal verklaard, maar de clausule implementeert Eeninterface.WhoAmI voltooit het contract tussen de klas en de interface.
laatste gedachten
structuren kunnen interfaces implementeren in VB.NET ook. Of een klasse of een structuur een interface implementeert, je hebt de Implements statement nodig zoals gedemonstreerd, en je moet elke methode die gedefinieerd is in de interface implementeren met behulp van de Implements clausule aan het einde van de procedure header om aan te geven dat een bepaalde methode voldoet aan een bepaalde interface methode.
Interfaces kunnen zeer kort of zeer lang zijn. Methoden beschreven door een interface kunnen subroutines of functies zijn, en ze kunnen zo uitgebreid of zo eenvoudig zijn als je nodig hebt. Eén methode kan meer dan één interfaces methode implementeren. Tot slot, houd in gedachten dat interface methoden kunnen worden aangeroepen met een verwijzing naar het object of met een verwijzing naar de interface.
over de auteur
Paul Kimmel is een freelance schrijver voor Developer.com en CodeGuru.com. Kijk voor coole Visual Basic. NET onderwerpen in zijn aanstaande boek Visual Basic.NET Unleashed beschikbaar in januari 2002.Paul richtte Software Conceptions, Inc.op. in 1990. Neem contact op met Paul Kimmel voor hulp bij het bouwen VB.NET toepassingen of VB6-toepassingen migreren naar. NET.
# # #
