Gebeurtenissen (Visual Basic)

Hoewel u een Visual Studio project kunt visualiseren als een reeks procedures die in een reeks worden uitgevoerd, zijn de meeste programma's in werkelijkheid gebeurtenisgestuurd, wat betekent dat de uitvoeringsstroom wordt bepaald door externe exemplaren 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. Met gebeurtenissen kunnen ook afzonderlijke taken communiceren. Stel dat uw toepassing een sorteertaak afzonderlijk van de hoofdtoepassing uitvoert. Als een gebruiker de sortering annuleert, kan uw toepassing een gebeurtenis voor annuleren 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. Het uitzenden van het bericht wordt het aanroepen van de gebeurtenis. 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.

Gebeurtenis-handlers

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

Visual Basic gebruikt een standaardnaamconventie voor gebeurtenis-handlers die de naam van de afzender van de gebeurtenis, een onderstrepingsteken en de naam van de gebeurtenis combineren. De gebeurtenis van een benoemde button1 knop zou bijvoorbeeld Click de naam Sub button1_Clickhebben.

Notitie

We raden u aan 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 gebeurtenis-handlers

Voordat een gebeurtenis-handler bruikbaar wordt, moet u deze eerst koppelen aan een gebeurtenis met behulp van de Handles of AddHandler instructie.

WithEvents and the Handles Clause

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 een 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 instructie en de Handles component zijn vaak de beste keuze voor gebeurtenis-handlers, omdat de declaratieve syntaxis die ze gebruiken, het verwerken van gebeurtenissen gemakkelijker te coderen, lezen en fouten opsporen. 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 gedeelde gebeurtenissen niet WithEvents declaratief afhandelen. Op dezelfde manier kunt WithEventsHandles u gebeurtenissen van een Structure. In beide gevallen kunt u de AddHandler instructie gebruiken om deze gebeurtenissen af te handelen.

• U kunt geen matrices met WithEvents variabelen maken.

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

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 met gebeurtenissen die zijn gekoppeld aan formulieren of besturingselementen, Visual Basic automatisch een lege gebeurtenis-handler aan elkaar koppelt en aan een gebeurtenis koppelt. Wanneer u bijvoorbeeld dubbelklikt op een opdrachtknop in een formulier in de ontwerpmodus, maakt Visual Basic een lege gebeurtenishandler 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. Maar, AddHandlergebruikt met RemoveHandler, biedt meer flexibiliteit dan de Handles component, zodat 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 gebruiken AddHandler.

AddHandler heeft twee argumenten: de naam van een gebeurtenis van een afzender van een gebeurtenis, zoals een besturingselement, en een expressie die resulteert in een gemachtigde. U hoeft de gemachtigde klasse 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 wordt gegenereerd door een object:

AddHandler Obj.XEvent, AddressOf Me.XEventHandler

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

RemoveHandler Obj.XEvent, AddressOf Me.XEventHandler

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

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

Ten slotte wordt de tweede gebeurtenis-handler verwijderd en wordt de gebeurtenis een derde keer gegenereerd. Omdat er geen gebeurtenis-handler meer is gekoppeld aan de gebeurtenis, 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 door hun basisklasse worden gegenereerd met behulp van de Handles MyBase instructie.

Gebeurtenissen uit 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. Bijvoorbeeld:

  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
Overzicht: gebeurtenissen declareren en genereren	Bevat een stapsgewijze beschrijving van het declareren en genereren van gebeurtenissen voor een klasse.
Walkthrough: Gebeurtenissen verwerken	Demonstreert hoe u een gebeurtenis-handlerprocedure 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 met overgenomen gebeurtenis-handlers oplossen in Visual Basic	Hier vindt u veelvoorkomende problemen die zich voordoen met gebeurtenis-handlers in overgenomen onderdelen.
Gebeurtenissen	Biedt een overzicht van het gebeurtenismodel in de .NET Framework.
Gebeurtenis-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.