Partager via

Comment s’abonner à des événements et les gérer en Visual Basic

Un événement est une action ou une occurrence, comme un clic de souris ou une limite de crédit dépassée, qui est reconnue par un composant de programme et pour laquelle vous pouvez écrire du code pour répondre. Un gestionnaire d’événements est le code que vous écrivez pour répondre à un événement.

Dans Visual Basic, il existe deux aspects dans le travail avec les événements :

  • Publication d’événements : les classes déclarent des événements et les déclenchent lorsque quelque chose d’intéressant se produit à l’aide de l’instruction RaiseEvent. C'est ce qui déclenche réellement les gestionnaires d'événements.
  • Abonnement aux événements : vous vous abonnez aux événements en identifiant les procédures en tant que gestionnaires d’événements spécifiques. Vous pouvez le faire avec une Handles clause et une WithEvents variable, ou avec une instruction AddHandler.

Un gestionnaire d’événements en Visual Basic est une Sub procédure. Votre code ne l'appelle pas directement comme les autres procédures Sub. Au lieu de cela, les éditeurs d’événements invoquent la procédure lorsque l’événement est déclenché, car la procédure est liée à l'événement.

L’utilisation d’une Handles clause est la méthode par défaut pour s’abonner aux événements en Visual Basic. C’est ainsi que les gestionnaires d’événements sont écrits par les concepteurs lorsque vous programmez dans l’environnement de développement intégré (IDE). L’instruction AddHandler convient pour s’abonner dynamiquement aux événements au moment de l’exécution.

Lorsque l’événement se produit, Visual Basic appelle automatiquement la procédure du gestionnaire d’événements. Tout code qui a accès à l’événement peut le provoquer en exécutant une instruction RaiseEvent.

Vous pouvez associer plusieurs gestionnaires d’événements au même événement. Dans certains cas, vous pouvez dissocier un gestionnaire d’un événement. Pour plus d’informations, consultez Événements.

S’abonner à un événement à l’aide Handles et WithEvents

  1. Vérifiez que l’événement est déclaré avec une instruction Event.

  2. Déclarez une variable d’objet au niveau du module ou de la classe à l’aide du WithEvents mot clé. La As clause de cette variable doit spécifier la classe qui déclenche l’événement.

  3. Dans la déclaration de la procédure de gestion Sub des événements, ajoutez une Handles clause qui spécifie la WithEvents variable et le nom de l’événement.

  4. Lorsque l’événement se produit, Visual Basic appelle automatiquement la Sub procédure. Votre code peut utiliser une RaiseEvent instruction pour déclencher l’événement et appeler tous les gestionnaires abonnés.

    L’exemple suivant définit un événement et une WithEvents variable qui fait référence à la classe qui déclenche l’événement. La procédure de gestion des Sub événements utilise une Handles clause pour spécifier la classe et l’événement qu’elle gère.

    ' Example showing event handling with Handles and WithEvents
Public Class EventPublisher
    Public Event SomethingHappened()
    
    Public Sub CauseEvent()
        ' Raise the event when something interesting happens
        RaiseEvent SomethingHappened()
    End Sub
End Class

Public Class EventSubscriber
    ' Declare a WithEvents variable
    Dim WithEvents eventObj As New EventPublisher
    
    ' Handle the event using Handles clause
    Public Sub ProcessHappen() Handles eventObj.SomethingHappened
        ' Insert code to handle somethingHappened event.
        Console.WriteLine("Event handled using Handles clause!")
    End Sub
    
    Public Sub TriggerEvent()
        eventObj.CauseEvent()
    End Sub
End Class

S’abonner à un événement à l’aide de AddHandler

  1. Vérifiez que l’événement est déclaré avec une Event déclaration.

  2. Exécutez une instruction AddHandler pour connecter dynamiquement la procédure de gestion des Sub événements à l’événement.

  3. Lorsque l’événement se produit, Visual Basic appelle automatiquement la Sub procédure. Votre code peut utiliser une RaiseEvent instruction pour déclencher l’événement et appeler tous les gestionnaires abonnés.

    L’exemple suivant utilise l’instruction AddHandler dans le constructeur pour associer la OnTimerElapsed procédure en tant que gestionnaire d’événements pour un événement de minuteur personnalisé.

    ' Example showing event handling with AddHandler
Public Class Timer
    Public Event TimerElapsed(ByVal message As String)
    
    Public Sub Start()
        ' Simulate timer elapsed
        RaiseEvent TimerElapsed("Timer has elapsed!")
    End Sub
End Class

Public Class Application
    Private appTimer As New Timer()
    
    Sub New()
        ' Use AddHandler to dynamically associate event handler
        AddHandler appTimer.TimerElapsed, AddressOf OnTimerElapsed
    End Sub

    Private Sub OnTimerElapsed(ByVal message As String)
        ' Insert code to handle timer elapsed event
        Console.WriteLine($"Handling timer event: {message}")
    End Sub
    
    Public Sub StartTimer()
        appTimer.Start()
    End Sub
End Class

    Vous pouvez dissocier un gestionnaire d’événements d’un événement en exécutant l’instruction RemoveHandler.

Voir aussi

  • Last updated on