Gebeurtenissen (Visual Basic)

Hoewel u een Visual Studio-project kunt visualiseren als een reeks procedures die in een reeks worden uitgevoerd, worden de meeste programma's in werkelijkheid gebeurtenisgestuurd, wat betekent dat de uitvoeringsstroom wordt bepaald door externe gebeurtenissen die gebeurtenissen worden genoemd.

Een gebeurtenis is een signaal dat een toepassing informeert dat er iets belangrijks is opgetreden. Wanneer een gebruiker bijvoorbeeld op een besturingselement in een formulier klikt, kan het formulier een Click gebeurtenis genereren en een procedure aanroepen waarmee de gebeurtenis wordt verwerkt. Gebeurtenissen zorgen er ook voor dat afzonderlijke taken kunnen communiceren. Stel dat uw toepassing een sorteertaak afzonderlijk van de hoofdtoepassing uitvoert. Als een gebruiker de sortering annuleert, kan uw toepassing een annuleringsevenement verzenden waarin het sorteerproces wordt geïnstrueerd om te stoppen.

Gebeurtenisvoorwaarden en -concepten

In deze sectie worden de termen en concepten beschreven die worden gebruikt met gebeurtenissen in Visual Basic.

Gebeurtenissen declareren

U declareert gebeurtenissen binnen klassen, structuren, modules en interfaces met behulp van het Event trefwoord, zoals in het volgende voorbeeld:

Event AnEvent(ByVal EventNumber As Integer)

Gebeurtenissen genereren

Een gebeurtenis lijkt op een bericht waarin wordt aangekondigd dat er iets belangrijks is opgetreden. De handeling van het uitzenden van het bericht wordt het aanroepen van het evenement genoemd. In Visual Basic genereert u gebeurtenissen met de RaiseEvent instructie, zoals in het volgende voorbeeld:

RaiseEvent AnEvent(EventNumber)

Gebeurtenissen moeten worden gegenereerd binnen het bereik van de klasse, module of structuur waar ze worden gedeclareerd. Een afgeleide klasse kan bijvoorbeeld geen gebeurtenissen genereren die zijn overgenomen van een basisklasse.

Afzenders van gebeurtenissen

Elk object dat een gebeurtenis kan genereren, is een afzender van een gebeurtenis, ook wel een gebeurtenisbron genoemd. Formulieren, besturingselementen en door de gebruiker gedefinieerde objecten zijn voorbeelden van afzenders van gebeurtenissen.

Gebeurtenishandlers

Gebeurtenis-handlers zijn procedures die worden aangeroepen wanneer een bijbehorende gebeurtenis plaatsvindt. U kunt elke geldige subroutine met een overeenkomende handtekening gebruiken als gebeurtenis-handler. U kunt een functie echter niet gebruiken als een gebeurtenishandler, omdat deze geen waarde kan retourneren aan de gebeurtenisbron.

Visual Basic maakt gebruik van een standaardnaamconventie voor gebeurtenis-handlers die de naam van de afzender van de gebeurtenis, een onderstrepingsteken en de naam van de gebeurtenis combineren. Bijvoorbeeld, de gebeurtenis van een knop genaamd Click zou de button1Sub button1_Click heten.

Opmerking

U wordt aangeraden deze naamconventie te gebruiken bij het definiëren van gebeurtenis-handlers voor uw eigen gebeurtenissen, maar dit is niet vereist; u kunt elke geldige subroutinenaam gebruiken.

Gebeurtenissen koppelen aan eventhandlers

Voordat een gebeurtenisafhandelaar bruikbaar wordt, moet u deze eerst koppelen aan een gebeurtenis door gebruik te maken van de Handles of AddHandler instructie.

WithEvents en de Handles-clausule

De WithEvents instructie en Handles component bieden een declaratieve manier om gebeurtenis-handlers op te geven. Een gebeurtenis die wordt gegenereerd door een object dat is gedeclareerd met het WithEvents trefwoord, kan worden verwerkt door elke procedure met een Handles instructie voor die gebeurtenis, zoals wordt weergegeven in het volgende voorbeeld:

' Declare a WithEvents variable.
Dim WithEvents EClass As New EventClass

' Call the method that raises the object's events.
Sub TestEvents()
    EClass.RaiseEvents()
End Sub

' Declare an event handler that handles multiple events.
Sub EClass_EventHandler() Handles EClass.XEvent, EClass.YEvent
    MsgBox("Received Event.")
End Sub

Class EventClass
    Public Event XEvent()
    Public Event YEvent()
    ' RaiseEvents raises both events.
    Sub RaiseEvents()
        RaiseEvent XEvent()
        RaiseEvent YEvent()
    End Sub
End Class

De WithEvents verklaring en de Handles clausule zijn vaak de beste keuze voor gebeurtenishandlers, omdat de declaratieve syntaxis die ze gebruiken, het verwerken van gebeurtenissen eenvoudiger maakt voor code, leesbaarheid en het opsporen van fouten. Houd echter rekening met de volgende beperkingen voor het gebruik van WithEvents variabelen:

• U kunt een WithEvents variabele niet gebruiken als objectvariabele. Dat wil zeggen dat u deze niet kunt declareren als Object: u moet de klassenaam opgeven wanneer u de variabele declareert.

• Omdat gedeelde gebeurtenissen niet zijn gekoppeld aan klasse-exemplaren, kunt u WithEvents niet declaratief behandelen. Op dezelfde manier kunt u WithEvents of Handles niet gebruiken om gebeurtenissen van een Structure te verwerken. In beide gevallen kunt u de AddHandler instructie gebruiken om deze gebeurtenissen af te handelen.

• U kunt geen matrices van WithEvents variabelen maken.

WithEvents Met variabelen kan één gebeurtenis-handler een of meer soorten gebeurtenissen verwerken, of een of meer gebeurtenis-handlers hetzelfde type gebeurtenis verwerken.

Hoewel de Handles component de standaardmethode is om een gebeurtenis te koppelen aan een gebeurtenis-handler, is het beperkt tot het koppelen van gebeurtenissen aan gebeurtenis-handlers tijdens het compileren.

In sommige gevallen, zoals bij gebeurtenissen die zijn gekoppeld aan formulieren of besturingselementen, maakt Visual Basic automatisch een lege gebeurtenis-handler aan en koppelt deze aan een gebeurtenis. Wanneer u bijvoorbeeld dubbelklikt op een opdrachtknop in een formulier in de ontwerpmodus, maakt Visual Basic een lege gebeurtenis-handler en een WithEvents variabele voor de opdrachtknop, zoals in de volgende code:

Friend WithEvents Button1 As System.Windows.Forms.Button
Protected Sub Button1_Click() Handles Button1.Click
End Sub

AddHandler en RemoveHandler

De AddHandler instructie is vergelijkbaar met de Handles component waarin u beide een gebeurtenis-handler kunt opgeven. Gebruikt AddHandler met RemoveHandler biedt echter meer flexibiliteit dan de Handles clausule, waardoor u de gebeurtenis-handler die aan een gebeurtenis is gekoppeld, dynamisch kunt toevoegen, verwijderen en wijzigen. Als u gedeelde gebeurtenissen of gebeurtenissen uit een structuur wilt verwerken, moet u dit gebruiken AddHandler.

AddHandler heeft twee argumenten: de naam van een gebeurtenis van een afzender van een gebeurtenis, zoals een controle, en een expressie die evalueert tot een delegate. U hoeft de gemachtigdeklasse niet expliciet op te geven wanneer u deze gebruikt AddHandler, omdat de AddressOf instructie altijd een verwijzing naar de gemachtigde retourneert. In het volgende voorbeeld wordt een gebeurtenis-handler gekoppeld aan een gebeurtenis die door een object wordt gegenereerd:

AddHandler Obj.XEvent, AddressOf Me.XEventHandler

RemoveHandler, waarmee een gebeurtenis wordt losgekoppeld van een gebeurtenis-handler, wordt dezelfde syntaxis gebruikt als AddHandler. Voorbeeld:

RemoveHandler Obj.XEvent, AddressOf Me.XEventHandler

In het volgende voorbeeld wordt een gebeurtenis-handler gekoppeld aan een gebeurtenis en wordt de gebeurtenis gegenereerd. De eventhandler vangt de gebeurtenis en geeft een bericht weer.

Vervolgens wordt de eerste gebeurtenis-handler verwijderd en is er een andere gebeurtenis-handler gekoppeld aan de gebeurtenis. Wanneer de gebeurtenis opnieuw wordt gegenereerd, wordt een ander bericht weergegeven.

Ten slotte wordt de tweede gebeurtenis-handler verwijderd en wordt de gebeurtenis voor een derde keer gegenereerd. Omdat er geen gebeurtenis-handler meer aan de gebeurtenis is gekoppeld, wordt er geen actie ondernomen.

Module Module1

    Sub Main()
        Dim c1 As New Class1
        ' Associate an event handler with an event.
        AddHandler c1.AnEvent, AddressOf EventHandler1
        ' Call a method to raise the event.
        c1.CauseTheEvent()
        ' Stop handling the event.
        RemoveHandler c1.AnEvent, AddressOf EventHandler1
        ' Now associate a different event handler with the event.
        AddHandler c1.AnEvent, AddressOf EventHandler2
        ' Call a method to raise the event.
        c1.CauseTheEvent()
        ' Stop handling the event.
        RemoveHandler c1.AnEvent, AddressOf EventHandler2
        ' This event will not be handled.
        c1.CauseTheEvent()
    End Sub

    Sub EventHandler1()
        ' Handle the event.
        MsgBox("EventHandler1 caught event.")
    End Sub

    Sub EventHandler2()
        ' Handle the event.
        MsgBox("EventHandler2 caught event.")
    End Sub

    Public Class Class1
        ' Declare an event.
        Public Event AnEvent()
        Sub CauseTheEvent()
            ' Raise an event.
            RaiseEvent AnEvent()
        End Sub
    End Class

End Module

Gebeurtenissen verwerken die zijn overgenomen van een basisklasse

Afgeleide klassen, klassen die kenmerken overnemen van een basisklasse, kunnen gebeurtenissen verwerken die zijn gegenereerd door hun basisklasse met behulp van de Handles MyBase instructie.

Gebeurtenissen van een basisklasse afhandelen

• Declareer een gebeurtenis-handler in de afgeleide klasse door een Handles MyBase.gebeurtenisnaaminstructie toe te voegen aan de declaratieregel van uw gebeurtenis-handlerprocedure, waarbij gebeurtenisnaam de naam is van de gebeurtenis in de basisklasse die u verwerkt. Voorbeeld:

  Public Class BaseClass
      Public Event BaseEvent(ByVal i As Integer)
      ' Place methods and properties here.
  End Class
  
  Public Class DerivedClass
      Inherits BaseClass
      Sub EventHandler(ByVal x As Integer) Handles MyBase.BaseEvent
          ' Place code to handle events from BaseClass here.
      End Sub
  End Class
  

Gerelateerde Secties

Titel	Beschrijving
Handleiding: gebeurtenissen declareren en activeren	Biedt een stapsgewijze beschrijving van het declareren en genereren van gebeurtenissen voor een klasse.
Stapsgewijze handleiding: Gebeurtenissen verwerken	Demonstreert hoe u een event-handler-procedure schrijft.
Procedure: Aangepaste gebeurtenissen declareren om blokkeren te voorkomen	Demonstreert hoe u een aangepaste gebeurtenis definieert waarmee de gebeurtenis-handlers asynchroon kunnen worden aangeroepen.
Procedure: Aangepaste gebeurtenissen declareren om geheugen te besparen	Demonstreert hoe u een aangepaste gebeurtenis definieert die alleen geheugen gebruikt wanneer de gebeurtenis wordt verwerkt.
Problemen oplossen met overgeërfde gebeurtenishandlers in Visual Basic	Lijst de veelvoorkomende problemen die zich voordoen met event handlers in geërfde componenten.
Gebeurtenissen	Biedt een overzicht van het gebeurtenismodel in .NET Framework.
Event-handlers maken in Windows Forms	Hierin wordt beschreven hoe u kunt werken met gebeurtenissen die zijn gekoppeld aan Windows Forms-objecten.
gedelegeerden	Biedt een overzicht van gemachtigden in Visual Basic.