Objecten en klassen in Visual Basic

2025-06-17

Een object is een combinatie van code en gegevens die als eenheid kunnen worden behandeld. Een object kan een deel van een toepassing zijn, zoals een besturingselement of een formulier. Een hele toepassing kan ook een object zijn.

Wanneer u een toepassing maakt in Visual Basic, werkt u voortdurend met objecten. U kunt objecten van Visual Basic gebruiken, zoals besturingselementen, formulieren en gegevenstoegangsobjecten. U kunt ook objecten uit andere toepassingen in uw Visual Basic-toepassing gebruiken. U kunt zelfs uw eigen objecten maken en aanvullende eigenschappen en methoden voor deze objecten definiëren. Objecten fungeren als geprefabriceerde bouwstenen voor programma's. Ze laten u een stuk code eenmaal schrijven en deze opnieuw gebruiken.

In dit onderwerp worden objecten in detail besproken.

Objecten en klassen

Elk object in Visual Basic wordt gedefinieerd door een klasse. Een klasse beschrijft de variabelen, eigenschappen, procedures en gebeurtenissen van een object. Objecten zijn exemplaren van klassen; u kunt zo veel objecten maken als u nodig hebt nadat u een klasse hebt gedefinieerd.

Als je de relatie tussen een object en de klasse ervan wilt begrijpen, kun je denken aan koekjesvormpjes en koekjes. De cookiesnijder is de klasse. Het definieert de kenmerken van elke cookie, bijvoorbeeld grootte en vorm. De klasse wordt gebruikt om objecten te maken. De objecten zijn de cookies.

U moet een object maken voordat u toegang hebt tot de leden, met uitzondering van Shared leden die toegankelijk zijn zonder een object van de klasse.

Een object maken op basis van een klasse

Bepaal op basis van welke klasse u een object wilt maken of definieer uw eigen klasse. Voorbeeld:
```
Public Class Customer
    Public Property AccountNumber As Integer
End Class
```
Schrijf een Dim-instructie om een variabele te maken waaraan u een klasse-exemplaar kunt toewijzen. De variabele moet van het type van de gewenste klasse zijn.
```
Dim nextCustomer As Customer
```
Voeg het trefwoord Nieuwe operator toe om de variabele te initialiseren naar een nieuw exemplaar van de klasse.
```
Dim nextCustomer As New Customer
```
U hebt nu toegang tot de leden van de klasse via de objectvariabele.
```
nextCustomer.AccountNumber = lastAccountNumber + 1
```

Opmerking

Indien mogelijk moet u de variabele declareren als van het klassetype dat u eraan wilt toewijzen. Dit wordt vroege binding genoemd. Als u het klassetype tijdens het compileren niet weet, kunt u late binding aanroepen door de variabele te declareren als van het objectgegevenstype. Late binding kan de prestaties echter langzamer maken en de toegang tot de leden van het runtimeobject beperken. Zie Declaratie van objectvariabele voor meer informatie.

Meerdere gevallen

Objecten die zijn gemaakt op basis van een klasse, zijn vaak identiek aan elkaar. Zodra ze bestaan als afzonderlijke objecten, kunnen hun variabelen en eigenschappen echter onafhankelijk van de andere exemplaren worden gewijzigd. Als u bijvoorbeeld drie selectievakjes aan een formulier toevoegt, is elk selectievakjeobject een exemplaar van de CheckBox klasse. De afzonderlijke CheckBox objecten delen een gemeenschappelijke set kenmerken en mogelijkheden (eigenschappen, variabelen, procedures en gebeurtenissen) die door de klasse zijn gedefinieerd. Elk heeft echter een eigen naam, kan afzonderlijk worden ingeschakeld en uitgeschakeld, en kan op een andere locatie op het formulier worden geplaatst.

Objectleden

Een object is een element van een toepassing, dat een exemplaar van een klasse vertegenwoordigt. Velden, eigenschappen, methoden en gebeurtenissen zijn de bouwstenen van objecten en vormen hun leden.

Toegang tot leden

U krijgt toegang tot een lid van een object door de naam van de objectvariabele, een punt (.) en de naam van het lid op te geven. In het volgende voorbeeld wordt de Text eigenschap van een Label object ingesteld.

warningLabel.Text = "Data not saved"

IntelliSense-vermelding van leden

IntelliSense vermeldt leden van een klasse wanneer u de optie Lijstleden aanroept, bijvoorbeeld wanneer u een punt (.) typt als operator voor ledentoegang. Als u de periode typt na de naam van een variabele die is gedeclareerd als een exemplaar van die klasse, vermeldt IntelliSense alle exemplaarleden en geen van de gedeelde leden. Als u de periode na de klassenaam zelf typt, worden intelliSense alle gedeelde leden en geen van de exemplaarleden vermeld. Zie IntelliSense gebruiken voor meer informatie.

Velden en eigenschappen

Velden en eigenschappen vertegenwoordigen gegevens die zijn opgeslagen in een object. U haalt de waarden op en stelt deze in met toewijzingsinstructies op dezelfde manier als u lokale variabelen ophaalt en instelt in een procedure. In het volgende voorbeeld wordt de Width eigenschap opgehaald en wordt de ForeColor eigenschap van een Label object ingesteld.

Dim warningWidth As Integer = warningLabel.Width
warningLabel.ForeColor = System.Drawing.Color.Red

Houd er rekening mee dat een veld ook wel een lidvariabele wordt genoemd.

Gebruik eigenschapsprocedures wanneer:

U moet bepalen wanneer en hoe een waarde wordt ingesteld of opgehaald.
De eigenschap heeft een goed gedefinieerde set waarden die moeten worden gevalideerd.
Als u de waarde instelt, wordt een bepaalde waarneembare wijziging in de status van het object veroorzaakt, zoals een IsVisible eigenschap.
Als u de eigenschap instelt, worden andere interne variabelen gewijzigd of worden de waarden van andere eigenschappen gewijzigd.
Er moet een reeks stappen worden uitgevoerd voordat de eigenschap kan worden ingesteld of opgehaald.

Velden gebruiken wanneer:

De waarde is van een zelfvaliderend type. Een fout of automatische gegevensconversie treedt bijvoorbeeld op als een andere waarde dan True of False is toegewezen aan een Boolean variabele.
Elke waarde in het bereik dat wordt ondersteund door het gegevenstype, is geldig. Dit geldt voor veel eigenschappen van het type Single of Double.
De eigenschap is een String gegevenstype en er is geen beperking voor de grootte of waarde van de tekenreeks.
Voor meer informatie, raadpleeg Eigenschappenprocedures.

Aanbeveling

Houd altijd de niet-constante velden privé. Wanneer je het openbaar wilt maken, gebruik dan een eigenschap in plaats daarvan.

Methoden

Een methode is een actie die een object kan uitvoeren. Bijvoorbeeld, Add is een methode van het ComboBox object die een nieuwe vermelding toevoegt aan een keuzelijst.

In het volgende voorbeeld ziet u de Start methode van een Timer object.

Dim safetyTimer As New System.Windows.Forms.Timer
safetyTimer.Start()

Houd er rekening mee dat een methode gewoon een procedure is die wordt weergegeven door een object.

Zie Proceduresvoor meer informatie.

Evenementen

Een gebeurtenis is een actie die wordt herkend door een object, zoals klikken met de muis of op een toets drukken, en waarvoor u code kunt schrijven om te reageren. Gebeurtenissen kunnen optreden als gevolg van een gebruikersactie of programmacode, of ze kunnen worden veroorzaakt door het systeem. Code die een gebeurtenis aangeeft, wordt gezegd om de gebeurtenis te genereren en code die erop reageert, wordt gezegd om deze te verwerken .

U kunt ook uw eigen aangepaste gebeurtenissen ontwikkelen die door uw objecten worden gegenereerd en door andere objecten worden verwerkt. Zie Gebeurtenissenvoor meer informatie.

Instantieleden en gedeelde leden

Wanneer u een object maakt op basis van een klasse, is het resultaat een exemplaar van die klasse. Leden die niet zijn gedeclareerd met het gedeelde trefwoord, zijn exemplaarleden, die strikt tot dat specifieke exemplaar behoren. Een instantie-lid in één instantie is onafhankelijk van hetzelfde lid in een andere instantie van dezelfde klasse. Een exemplaarlidvariabele kan bijvoorbeeld verschillende waarden hebben in verschillende exemplaren.

Leden die met het Shared keyword zijn gedeclareerd, zijn gedeelde leden, die deel uitmaken van de klasse als geheel en niet tot een bepaalde instantie. Een gedeeld lid bestaat slechts één keer, ongeacht het aantal exemplaren van de klasse dat u maakt, of zelfs als u geen exemplaren maakt. Een gedeelde lidvariabele heeft bijvoorbeeld slechts één waarde, die beschikbaar is voor alle code die toegang heeft tot de klasse.

Toegang tot niet-gedeelde leden

Zorg ervoor dat het object is gemaakt op basis van de klasse en is toegewezen aan een objectvariabele.
```
Dim secondForm As New System.Windows.Forms.Form
```
Volg in de instructie die toegang geeft tot het lid de naam van de objectvariabele met de operator voor lidtoegang (.) en vervolgens de lidnaam.
```
secondForm.Show()
```

Toegang tot gedeelde leden

Volg de klassenaam vervolgens met de operator voor lidtoegang (.) en daarna de naam van het lid. U moet altijd rechtstreeks toegang krijgen tot een Shared lid van het object via de klassenaam.
```
Console.WriteLine("This computer is called " & Environment.MachineName)
```
Als u al een object hebt gemaakt op basis van de klasse, kunt u ook toegang krijgen tot een Shared lid via de variabele van het object.

Verschillen tussen klassen en modules

Het belangrijkste verschil tussen klassen en modules is dat klassen kunnen worden geïnstantieerd als objecten, terwijl standaardmodules dat niet kunnen. Omdat er slechts één kopie van de gegevens van een standaardmodule is, krijgt elk ander deel van het programma dezelfde waarde als het ene deel van uw programma een openbare variabele in een standaardmodule wijzigt. Objectgegevens bestaan daarentegen afzonderlijk voor elk geïnstantieerd object. Een ander verschil is dat in tegenstelling tot standaardmodules klassen interfaces kunnen implementeren. Als een klasse is gemarkeerd met de MustInherit-modifier , kan deze niet rechtstreeks worden geïnstantieerd. Het is echter nog steeds anders dan een module omdat het kan worden overgenomen, terwijl modules dat niet kunnen.

Opmerking

Wanneer de Shared wijzigingsfunctie wordt toegepast op een klasselid, wordt deze gekoppeld aan de klasse zelf in plaats van een bepaald exemplaar van de klasse. Het lid wordt rechtstreeks toegewezen met behulp van de klassenaam, op dezelfde manier als moduleleden worden toegewezen.

Klassen en modules gebruiken ook verschillende toepassingsgebieden voor hun leden. Leden die binnen een klasse zijn gedefinieerd, vallen binnen een specifiek exemplaar van de klasse en bestaan alleen voor de levensduur van het object. Als u toegang wilt krijgen tot leden van een klasse van buiten de klasse, moet u volledig gekwalificeerde namen gebruiken in de indeling Object.Lid.

Aan de andere kant zijn leden die in een module zijn gedeclareerd, standaard openbaar toegankelijk en kunnen ze worden geopend door elke code die toegang heeft tot de module. Dit betekent dat variabelen in een standaardmodule in feite globale variabelen zijn, omdat ze overal in uw project zichtbaar zijn en ze bestaan voor de levensduur van het programma.

Klassen en objecten opnieuw gebruiken

Met objecten kunt u variabelen en procedures eenmaal declareren en deze vervolgens opnieuw gebruiken wanneer dat nodig is. Als u bijvoorbeeld een spellingcontrole wilt toevoegen aan een toepassing, kunt u alle variabelen en ondersteuningsfuncties definiëren om spellingcontrolefunctionaliteit te bieden. Als u de spellingcontrole als klasse maakt, kunt u deze vervolgens opnieuw gebruiken in andere toepassingen door een verwijzing naar de gecompileerde assembly toe te voegen. Nog beter, misschien kunt u uzelf wat werk besparen met behulp van een spellingcontroleklasse die iemand anders al heeft ontwikkeld.

.NET biedt veel voorbeelden van onderdelen die beschikbaar zijn voor gebruik. In het volgende voorbeeld wordt de TimeZone klasse in de System naamruimte gebruikt. TimeZone biedt leden waarmee u informatie over de tijdzone van het huidige computersysteem kunt ophalen.

Public Sub ExamineTimeZone()
    Dim tz As System.TimeZone = System.TimeZone.CurrentTimeZone
    Dim s As String = "Current time zone is "
    s &= CStr(tz.GetUtcOffset(Now).Hours) & " hours and "
    s &= CStr(tz.GetUtcOffset(Now).Minutes) & " minutes "
    s &= "different from UTC (coordinated universal time)"
    s &= vbCrLf & "and is currently "
    If tz.IsDaylightSavingTime(Now) = False Then s &= "not "
    s &= "on ""summer time""."
    Console.WriteLine(s)
End Sub

In het voorgaande voorbeeld declareert de eerste Dim-instructie een objectvariabele van het type TimeZone en wijst deze toe aan een TimeZone object dat door de CurrentTimeZone eigenschap wordt geretourneerd.

Relaties tussen objecten

Objecten kunnen op verschillende manieren aan elkaar zijn gerelateerd. De belangrijkste soorten relaties zijn hiërarchisch en insluiting.

Hiërarchische relatie

Wanneer klassen worden afgeleid van meer fundamentele klassen, wordt gezegd dat ze een hiërarchische relatie hebben. Klassehiërarchieën zijn handig bij het beschrijven van items die een subtype van een meer algemene klasse zijn.

Stel dat u in het volgende voorbeeld een speciaal type Button wilt definiëren dat als normaal Button fungeert, maar ook een methode beschikbaar maakt waarmee de voorgrond- en achtergrondkleuren worden omgekeerd.

Een klasse definiëren die is afgeleid van een al bestaande klasse

Gebruik een klasse-instructie om een klasse te definiëren waaruit u het gewenste object wilt maken.
```
Public Class ReversibleButton
```
Zorg ervoor dat een End Class statement de laatste regel code in uw klasse volgt. Standaard genereert de geïntegreerde ontwikkelomgeving (IDE) automatisch een End Class instructie wanneer u een Class instructie invoert.
Volg de Class instructie onmiddellijk met een Inherits-instructie. Geef de klasse op waaruit uw nieuwe klasse is afgeleid.
```
Inherits System.Windows.Forms.Button
```
Uw nieuwe klasse neemt alle leden over die zijn gedefinieerd door de basisklasse.
Voeg de code toe voor de extra leden die uw afgeleide klasse beschikbaar maakt. U kunt bijvoorbeeld een ReverseColors methode toevoegen en uw afgeleide klasse kan er als volgt uitzien:
```
Public Class ReversibleButton
    Inherits System.Windows.Forms.Button
        Public Sub ReverseColors()
            Dim saveColor As System.Drawing.Color = Me.BackColor
            Me.BackColor = Me.ForeColor
            Me.ForeColor = saveColor
       End Sub
End Class
```
Als u een object maakt op basis van de ReversibleButton klasse, heeft het toegang tot alle leden van de Button klasse, evenals de ReverseColors methode en eventuele andere nieuwe leden die u definieert.ReversibleButton

Afgeleide klassen nemen leden over van de klasse waarop ze zijn gebaseerd, zodat u complexiteit kunt toevoegen tijdens de voortgang in een klassehiërarchie. Zie Basisbeginselen van overname voor meer informatie.

De code compileren

Zorg ervoor dat de compiler toegang heeft tot de klasse waaruit u uw nieuwe klasse wilt afleiden. Dit kan betekenen dat de naam volledig in aanmerking komt, zoals in het vorige voorbeeld, of het identificeren van de naamruimte in een importinstructie (.NET-naamruimte en -type). Als de klasse zich in een ander project bevindt, moet u mogelijk een verwijzing naar dat project toevoegen. Zie Verwijzingen in een project beheren voor meer informatie.

Insluitingsrelatie

Een andere manier waarop objecten kunnen worden gerelateerd, is een insluitingsrelatie. Containerobjecten kapselen logisch andere objecten in. Bijvoorbeeld, het OperatingSystem object bevat logisch een Version object, dat het retourneert via zijn Version eigenschap. Houd er rekening mee dat het containerobject geen fysiek ander object bevat.

Verzamelingen

Een bepaald type object insluiting wordt vertegenwoordigd door verzamelingen. Verzamelingen zijn groepen vergelijkbare objecten die kunnen worden geïnventariseerd. Visual Basic ondersteunt een specifieke syntaxis in de For Each... Next-instructie waarmee u door de items van een verzameling kunt itereren. Daarnaast kunt u met verzamelingen vaak elementen Item[] ophalen op basis van hun index of door ze te koppelen aan een unieke tekenreeks. Verzamelingen kunnen eenvoudiger worden gebruikt dan matrices, omdat u hiermee items kunt toevoegen of verwijderen zonder indexen te gebruiken. Vanwege hun gebruiksgemak worden verzamelingen vaak gebruikt om formulieren en besturingselementen op te slaan.

Overzicht: Klassen definiëren
Biedt een stapsgewijze beschrijving van het maken van een klasse.

Overbelaste eigenschappen en methoden
Overbelaste eigenschappen en methoden

Basisprincipes van overname
Behandelt overervingsmodificatoren, overschrijvende methoden en eigenschappen, MyClass en MyBase.

Levensduur van objecten: hoe objecten worden gemaakt en vernietigd
Het maken en verwijderen van klasse-exemplaren wordt besproken.

Anonieme typen
Hierin wordt beschreven hoe u anonieme typen maakt en gebruikt, zodat u objecten kunt maken zonder een klassedefinitie voor het gegevenstype te schrijven.

Object Initializers: Benoemde en Anonieme Typen
Beschrijft object-initialisatiefuncties, die worden gebruikt om exemplaren van benoemde en anonieme typen te maken met behulp van één expressie.

Procedure: Eigenschapsnamen en -typen afleiden in anonieme typedeclaraties
Hierin wordt uitgelegd hoe u eigenschapsnamen en typen in anonieme typedeclaraties kunt afleiden. Biedt voorbeelden van geslaagde en mislukte deductie.

Delen via