Événements (Visual Basic)

2025-06-22

Même si vous pouvez visualiser un projet Visual Studio sous la forme d’une série de procédures qui s’exécutent dans une séquence, en réalité, la plupart des programmes sont pilotés par les événements, ce qui signifie que le flux d’exécution est déterminé par des occurrences externes appelées événements.

Un événement est un signal qui informe une application que quelque chose d’important a eu lieu. Par exemple, lorsqu’un utilisateur clique sur un contrôle sur un formulaire, le formulaire peut déclencher un Click événement et appeler une procédure qui gère l’événement. Les événements autorisent également des tâches distinctes à communiquer. Supposons, par exemple, que votre application effectue une tâche de tri séparément de l’application principale. Si un utilisateur annule le tri, votre application peut envoyer un événement d’annulation indiquant au processus de tri de s’arrêter.

Termes et concepts de l’événement

Cette section décrit les termes et concepts utilisés avec les événements en Visual Basic.

Déclaration d’événements

Vous déclarez des événements dans des classes, des structures, des modules et des interfaces à l’aide du Event mot clé, comme dans l’exemple suivant :

Event AnEvent(ByVal EventNumber As Integer)

Déclenchement d’événements

Un événement est similaire à un message annonçant que quelque chose d’important s’est produit. L’acte de diffusion du message est appelé déclenchement de l’événement. Dans Visual Basic, vous déclenchez des événements avec l’instruction RaiseEvent , comme dans l’exemple suivant :

RaiseEvent AnEvent(EventNumber)

Les événements doivent être déclenchés dans l’étendue de la classe, du module ou de la structure où ils sont déclarés. Par exemple, une classe dérivée ne peut pas déclencher des événements hérités d’une classe de base.

Expéditeurs d’événements

Tout objet capable de déclencher un événement est un expéditeur d’événement, également appelé source d’événement. Les formulaires, les contrôles et les objets définis par l’utilisateur sont des exemples d’expéditeurs d’événements.

Gestionnaires d’événements

Les gestionnaires d’événements sont des procédures appelées lorsqu’un événement correspondant se produit. Vous pouvez utiliser n’importe quelle sous-routine valide avec une signature correspondante en tant que gestionnaire d’événements. Toutefois, vous ne pouvez pas utiliser une fonction comme gestionnaire d’événements, car elle ne peut pas retourner une valeur à la source d’événement.

Visual Basic utilise une convention d’affectation de noms standard pour les gestionnaires d’événements qui combinent le nom de l’expéditeur de l’événement, un trait de soulignement et le nom de l’événement. Par exemple, l’événement Click d’un bouton nommé button1 serait nommé Sub button1_Click.

Remarque

Nous vous recommandons d’utiliser cette convention d’affectation de noms lors de la définition de gestionnaires d’événements pour vos propres événements, mais elle n’est pas requise ; vous pouvez utiliser n’importe quel nom de sous-routine valide.

Association d’événements à des gestionnaires d’événements

Avant qu’un gestionnaire d’événements ne devienne utilisable, vous devez d’abord l’associer à un événement à l’aide de l’instruction ou AddHandler de l’instructionHandles.

WithEvents et la clause Handles

L’instruction et Handles la WithEvents clause fournissent un moyen déclaratif de spécifier des gestionnaires d’événements. Un événement déclenché par un objet déclaré avec le WithEvents mot clé peut être géré par n’importe quelle procédure avec une Handles instruction pour cet événement, comme illustré dans l’exemple suivant :

' 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

L’instruction WithEvents et la Handles clause sont souvent le meilleur choix pour les gestionnaires d’événements, car la syntaxe déclarative qu’ils utilisent facilitent la gestion des événements pour coder, lire et déboguer. Toutefois, tenez compte des limitations suivantes sur l’utilisation de WithEvents variables :

Vous ne pouvez pas utiliser une WithEvents variable comme variable d’objet. Autrement dit, vous ne pouvez pas le déclarer en tant que Object: vous devez spécifier le nom de classe lorsque vous déclarez la variable.
Étant donné que les événements partagés ne sont pas liés aux instances de classe, vous ne pouvez pas utiliser WithEvents pour gérer de manière déclarative les événements partagés. De même, vous ne pouvez pas utiliser WithEvents ou Handles gérer des événements à partir d’un Structure. Dans les deux cas, vous pouvez utiliser l’instruction AddHandler pour gérer ces événements.
Vous ne pouvez pas créer de tableaux de WithEvents variables.

WithEvents les variables permettent à un seul gestionnaire d’événements de gérer un ou plusieurs types d’événements, ou un ou plusieurs gestionnaires d’événements pour gérer le même type d’événement.

Bien que la Handles clause soit la méthode standard d’association d’un événement à un gestionnaire d’événements, elle est limitée à l’association d’événements à des gestionnaires d’événements au moment de la compilation.

Dans certains cas, comme les événements associés aux formulaires ou contrôles, Visual Basic supprime automatiquement un gestionnaire d’événements vide et l’associe à un événement. Par exemple, lorsque vous double-cliquez sur un bouton de commande sur un formulaire en mode Création, Visual Basic crée un gestionnaire d’événements vide et une WithEvents variable pour le bouton de commande, comme dans le code suivant :

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

AddHandler et RemoveHandler

L’instruction AddHandler est similaire à la Handles clause dans laquelle les deux vous permettent de spécifier un gestionnaire d’événements. Toutefois, utilisé AddHandleravec RemoveHandler, offre une plus grande flexibilité que la Handles clause, ce qui vous permet d’ajouter, de supprimer et de modifier dynamiquement le gestionnaire d’événements associé à un événement. Si vous souhaitez gérer des événements ou des événements partagés à partir d’une structure, vous devez utiliser AddHandler.

AddHandler prend deux arguments : le nom d’un événement d’un expéditeur d’événement tel qu’un contrôle et une expression qui prend la valeur d’un délégué. Vous n’avez pas besoin de spécifier explicitement la classe de délégué lors de l’utilisation AddHandler, car l’instruction AddressOf retourne toujours une référence au délégué. L’exemple suivant associe un gestionnaire d’événements à un événement déclenché par un objet :

AddHandler Obj.XEvent, AddressOf Me.XEventHandler

RemoveHandler, qui déconnecte un événement d’un gestionnaire d’événements, utilise la même syntaxe que AddHandler. Par exemple:

RemoveHandler Obj.XEvent, AddressOf Me.XEventHandler

Dans l’exemple suivant, un gestionnaire d’événements est associé à un événement et l’événement est déclenché. Le gestionnaire d’événements intercepte l’événement et affiche un message.

Ensuite, le premier gestionnaire d’événements est supprimé et un autre gestionnaire d’événements est associé à l’événement. Lorsque l’événement est à nouveau déclenché, un autre message s’affiche.

Enfin, le deuxième gestionnaire d’événements est supprimé et l’événement est déclenché pour une troisième fois. Étant donné qu’il n’existe plus de gestionnaire d’événements associé à l’événement, aucune action n’est effectuée.

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

Gestion des événements hérités d’une classe de base

Les classes dérivées ( classes qui héritent des caractéristiques d’une classe de base) peuvent gérer les événements déclenchés par leur classe de base à l’aide de l’instruction Handles MyBase .

Pour gérer les événements à partir d’une classe de base

Déclarez un gestionnaire d’événements dans la classe dérivée en ajoutant une Handles MyBase. instruction eventname à la ligne de déclaration de votre procédure de gestionnaire d’événements, où eventname est le nom de l’événement dans la classe de base que vous gérez. Par exemple:

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

Titre	Descriptif
Procédure pas à pas : déclaration et déclenchement d’événements	Fournit une description pas à pas de la façon de déclarer et de déclencher des événements pour une classe.
Procédure pas à pas : gestion des événements	Montre comment écrire une procédure de gestionnaire d’événements.
Procédure : déclarer des événements personnalisés pour éviter le blocage	Montre comment définir un événement personnalisé qui permet à ses gestionnaires d’événements d’être appelés de façon asynchrone.
Procédure : déclarer des événements personnalisés pour conserver la mémoire	Montre comment définir un événement personnalisé qui utilise la mémoire uniquement lorsque l’événement est géré.
Résolution des problèmes liés aux gestionnaires d’événements hérités dans Visual Basic	Répertorie les problèmes courants qui surviennent avec les gestionnaires d’événements dans les composants hérités.
Événements	Fournit une vue d’ensemble du modèle d’événement dans .NET Framework.
Création de gestionnaires d’événements dans Windows Forms	Décrit comment utiliser des événements associés à des objets Windows Forms.
délégués	Fournit une vue d’ensemble des délégués en Visual Basic.

Partager via