Partager via

Event, instruction

Déclare un événement défini par l’utilisateur.

Syntaxe

[ <attrlist> ] [ accessmodifier ] _  
[ Shared ] [ Shadows ] Event eventname[(parameterlist)] _  
[ Implements implementslist ]  
' -or-  
[ <attrlist> ] [ accessmodifier ] _  
[ Shared ] [ Shadows ] Event eventname As delegatename _  
[ Implements implementslist ]  
' -or-  
 [ <attrlist> ] [ accessmodifier ] _  
[ Shared ] [ Shadows ] Custom Event eventname As delegatename _  
[ Implements implementslist ]  
   [ <attrlist> ] AddHandler(ByVal value As delegatename)  
      [ statements ]  
   End AddHandler  
   [ <attrlist> ] RemoveHandler(ByVal value As delegatename)  
      [ statements ]  
   End RemoveHandler  
   [ <attrlist> ] RaiseEvent(delegatesignature)  
      [ statements ]  
   End RaiseEvent  
End Event

Pièces

Composant Descriptif
attrlist Optionnel. Liste des attributs qui s’appliquent à cet événement. Plusieurs attributs sont séparés par des virgules. Vous devez placer la liste d’attributs entre crochets< (« » et «> »).
accessmodifier Optionnel. Spécifie le code qui peut accéder à l’événement. Il peut s’agir de l’un des éléments suivants :

- Public : tout code pouvant accéder à l’élément qui le déclare peut y accéder.
- Protégé : seul le code dans sa classe ou une classe dérivée peut y accéder.
- Friend : seul le code dans le même assembly peut y accéder.
- Private : seul le code dans l’élément qui le déclare peut y accéder.
- Le code Friend-only protégé dans la classe de l’événement, une classe dérivée ou le même assembly peut y accéder.
- Le code protégé privé uniquement dans la classe de l’événement ou une classe dérivée dans le même assembly peut y accéder.
Shared Optionnel. Spécifie que cet événement n’est pas associé à une instance spécifique d’une classe ou d’une structure.
Shadows Optionnel. Indique que cet événement redeclare et masque un élément de programmation nommé identiquement, ou un ensemble d’éléments surchargés, dans une classe de base. Vous pouvez masquer n’importe quel type d’élément déclaré avec n’importe quel autre type.

Un élément ombré n’est pas disponible à partir de la classe dérivée qui l’ombre, à l’exception de l’endroit où l’élément d’ombre est inaccessible. Par exemple, si un Private élément ombrage un élément de classe de base, le code qui n’a pas l’autorisation d’accéder à l’élément Private de classe de base accède à la place.
eventname Obligatoire. Nom de l’événement ; suit les conventions d’affectation de noms de variables standard.
parameterlist Optionnel. Liste des variables locales qui représentent les paramètres de cet événement. Vous devez placer la liste de paramètres entre parenthèses.
Implements Optionnel. Indique que cet événement implémente un événement d’une interface.
implementslist Obligatoire si Implements elle est fournie. Liste des procédures en cours d’implémentation Sub . Plusieurs procédures sont séparées par des virgules :

implementedprocedure [ , implementedprocedure ... ]

Chacune implementedprocedure a la syntaxe et les parties suivantes :

interface.definedname

- interface -Obligatoire. Nom d’une interface que cette procédure contient ou structure implémente.
- Definedname -Obligatoire. Nom par lequel la procédure est définie dans interface. Cela ne doit pas être le même que name, le nom que cette procédure utilise pour implémenter la procédure définie.
Custom Obligatoire. Les événements déclarés comme Custom doivent définir des accesseurs, RemoveHandleret RaiseEvent personnalisésAddHandler.
delegatename Optionnel. Nom d’un délégué qui spécifie la signature du gestionnaire d’événements.
AddHandler Obligatoire. Déclare un AddHandler accesseur, qui spécifie les instructions à exécuter lorsqu’un gestionnaire d’événements est ajouté, soit explicitement à l’aide de l’instruction AddHandler , soit implicitement à l’aide de la Handles clause.
End AddHandler Obligatoire. Termine le AddHandler bloc.
value Obligatoire. Nom du paramètre.
RemoveHandler Obligatoire. Déclare un RemoveHandler accesseur, qui spécifie les instructions à exécuter lorsqu’un gestionnaire d’événements est supprimé à l’aide de l’instruction RemoveHandler .
End RemoveHandler Obligatoire. Termine le RemoveHandler bloc.
RaiseEvent Obligatoire. Déclare un RaiseEvent accesseur, qui spécifie les instructions à exécuter lorsque l’événement est déclenché à l’aide de l’instruction RaiseEvent . En règle générale, cela appelle une liste de délégués gérés par les accesseurs et RemoveHandler les AddHandler accesseurs.
End RaiseEvent Obligatoire. Termine le RaiseEvent bloc.
delegatesignature Obligatoire. Liste des paramètres qui correspondent aux paramètres requis par le delegatename délégué. Vous devez placer la liste de paramètres entre parenthèses.
statements Optionnel. Instructions qui contiennent les corps du AddHandler, RemoveHandleret RaiseEvent des méthodes.
End Event Obligatoire. Termine le Event bloc.

Remarques

Une fois l’événement déclaré, utilisez l’instruction RaiseEvent pour déclencher l’événement. Un événement classique peut être déclaré et déclenché comme indiqué dans les fragments suivants :

Public Class EventSource
    ' Declare an event.
    Public Event LogonCompleted(ByVal UserName As String)
    Sub CauseEvent()
        ' Raise an event on successful logon.
        RaiseEvent LogonCompleted("AustinSteele")
    End Sub
End Class

Remarque

Vous pouvez déclarer des arguments d’événement comme vous le faites des arguments de procédures, à l’exception suivante : les événements ne peuvent pas avoir d’arguments nommés, ParamArray d’arguments ou Optional d’arguments. Les événements n’ont pas de valeurs de retour.

Pour gérer un événement, vous devez l’associer à une sous-routine de gestionnaire d’événements à l’aide de l’instruction ou AddHandler de l’instructionHandles. Les signatures de la sous-routine et de l’événement doivent correspondre. Pour gérer un événement partagé, vous devez utiliser l’instruction AddHandler .

Vous ne pouvez utiliser Event qu’au niveau du module. Cela signifie que le contexte de déclaration d’un événement doit être une classe, une structure, un module ou une interface, et ne peut pas être un fichier source, un espace de noms, une procédure ou un bloc. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

Dans la plupart des cas, vous pouvez utiliser la première syntaxe de la section Syntaxe de cette rubrique pour déclarer des événements. Toutefois, certains scénarios nécessitent un contrôle plus approfondi sur le comportement détaillé de l’événement. La dernière syntaxe de la section Syntaxe de cette rubrique, qui utilise le Custom mot clé, fournit ce contrôle en vous permettant de définir des événements personnalisés. Dans un événement personnalisé, vous spécifiez exactement ce qui se produit lorsque le code ajoute ou supprime un gestionnaire d’événements à ou à partir de l’événement, ou lorsque le code déclenche l’événement. Pour obtenir des exemples, consultez Comment : déclarer des événements personnalisés pour conserver la mémoire et comment : déclarer des événements personnalisés pour éviter le blocage.

Exemple :

L’exemple suivant utilise des événements pour compter les secondes de 10 à 0. Le code illustre plusieurs méthodes, propriétés et instructions liées aux événements. Cela inclut l’instruction RaiseEvent .

La classe qui déclenche un événement est la source d’événement et les méthodes qui traitent l’événement sont les gestionnaires d’événements. Une source d’événement peut avoir plusieurs gestionnaires pour les événements qu’elle génère. Lorsque la classe déclenche l’événement, cet événement est déclenché sur chaque classe qui a choisi de gérer les événements pour cette instance de l’objet.

L’exemple utilise également un formulaire (Form1) avec un bouton (Button1) et une zone de texte (TextBox1). Lorsque vous cliquez sur le bouton, la première zone de texte affiche un compte à rebours de 10 à 0 secondes. Lorsque le temps plein (10 secondes) s’est écoulé, la première zone de texte affiche « Terminé ».

Code pour Form1 spécifier les états initiaux et terminal du formulaire. Il contient également le code exécuté lors du déclenchement des événements.

Pour utiliser cet exemple, ouvrez un nouveau projet Windows Forms. Ajoutez ensuite un bouton nommé Button1 et une zone de texte nommée TextBox1 au formulaire principal, nommée Form1. Cliquez ensuite avec le bouton droit sur le formulaire, puis cliquez sur Afficher le code pour ouvrir l’éditeur de code.

Ajoutez une WithEvents variable à la section déclarations de la Form1 classe :

Private WithEvents mText As TimerState

Ajoutez le code suivant au code pour Form1. Remplacez les procédures en double qui peuvent exister, telles que Form_Load ou Button_Click.

Private Sub Form1_Load() Handles MyBase.Load
    Button1.Text = "Start"
    mText = New TimerState
End Sub
Private Sub Button1_Click() Handles Button1.Click
    mText.StartCountdown(10.0, 0.1)
End Sub

Private Sub mText_ChangeText() Handles mText.Finished
    TextBox1.Text = "Done"
End Sub

Private Sub mText_UpdateTime(ByVal Countdown As Double
  ) Handles mText.UpdateTime

    TextBox1.Text = Format(Countdown, "##0.0")
    ' Use DoEvents to allow the display to refresh.
    My.Application.DoEvents()
End Sub

Class TimerState
    Public Event UpdateTime(ByVal Countdown As Double)
    Public Event Finished()
    Public Sub StartCountdown(ByVal Duration As Double,
                              ByVal Increment As Double)
        Dim Start As Double = DateAndTime.Timer
        Dim ElapsedTime As Double = 0

        Dim SoFar As Double = 0
        Do While ElapsedTime < Duration
            If ElapsedTime > SoFar + Increment Then
                SoFar += Increment
                RaiseEvent UpdateTime(Duration - SoFar)
            End If
            ElapsedTime = DateAndTime.Timer - Start
        Loop
        RaiseEvent Finished()
    End Sub
End Class

Appuyez sur F5 pour exécuter l’exemple précédent, puis cliquez sur le bouton intitulé Démarrer. La première zone de texte commence à compter les secondes. Lorsque le temps plein (10 secondes) s’est écoulé, la première zone de texte affiche « Terminé ».

Remarque

La My.Application.DoEvents méthode ne traite pas les événements de la même façon que le formulaire. Pour permettre au formulaire de gérer directement les événements, vous pouvez utiliser le multithreading. Pour plus d’informations, consultez Managed Threading.

Voir aussi