www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Visual Basic .Net 2005 > II Créer évènements

____________________________________________________________________________________________________

Connexion

II) CREER SES PROPRES EVENEMENTS EN Visual Basic .NET

Il est bon de savoir créer ses propres évènements, afin de pouvoir faire sa propre programmation évènementielle.
Il est possible de réaliser cela en Visual Basic .net, mais aussi en C# et en c++ .net . Voici les différentes étapes à suivre.
Prenons l'exemple d'une classe voiture, qui crée des objets voiture. On veut pouvoir disposer d'un évènement FREINE, qu'on déclenchera au freinage d'une voiture.

II.1) Rappel sur les procédures liées( aux évènements)

On peut observer très facilement, par rapport aux lignes générées automatiquement par visual studio en cas d'évènement windows, que la procédure liée est de la forme suivante

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

Ceci est donc une procédure qui sera appelée en cas de click sur le bouton1.
Le 'Handles' est un mot-clé spécifique à VB, qui permet d'indiquer qu'on souhaite lier cette procédure à l'évènement click du Button1. 'Button1.Click' veut dire: l'évènement Click de l'objet Button1. Car l'objet Button1 possède un membre event( nous verrons bientôt ce qu'est un membre event), qui s'appelle Click, mais qui n'est pas visible en VB par le programmeur de l'objet Button1.

Cette procédure Button1_Click possède deux paramètres.

- sender, qui est un objet. sender est l'objet qui a émis l'évènement. L'émetteur de l'évènement peut y mettre ce qu'il veut. C'est juste une information pour la procédure liée, pour la renseigner. Ici, le sender est l'objet button1, donc on n'a pas l'impression que ce paramètre est utile. Mais parfois, il est nécessaire. Par exemple, dans notre cas, on pourrait y mettre la voiture qui freine.

- L'argument e est un objet, qui encapsule toutes les informations intéressantes concernant l'évènement. Par exemple, dans le cas d'un appui sur une touche, le code de la touche pressée.
Dans notre cas, cela peut être les circonstances au moment du freinage( pluie, soleil, etc), la vitesse au moment de freiner, etc.
Cet argument doit forcément être d'une classe qui hérite de la classe System.EventArgs . Par exemple, dans le cas de l'évènement KeyDown:

Private Sub Form1_KeyDown(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles Me.KeyDown

Le e ici est de la classe KeyEventArgs, qui est une classe qui hérite de la classe EventArgs. La classe KeyEventArgs est spécialement adaptée pour cet évènement. Elle possède notamment un attribut e.KeyCode, qui est le code de la touche pressée. Ce KeyCode ne figure pas, par contre, dans la classe EventArgs. Cet objet e est là pour aider la procédure liée. Pour lui donner des informations que l'évènement KeyDown seul, ne suffit pas à donner( il nous indique juste qu'une touche a été enfoncée). Le e est donc nécessaire.

II.2) La procédure à suivre pour créer ses évènements

Pour créer ses propres évènements, la façon de procéder est composée de plusieurs parties.

- Créer sa propre classe EventArgs
- Se créer une classe EmetEvent, qui permettra de créer un objet émetteur d'évènements.
- Procéder à quelques déclarations et initialisations, à l'extérieur, par exemple dans la classe Form1( votre classe de formulaire principal). Par exemple se créer un objet émetteur d'évènements.

Nous étudierons un exemple complet, celui des objets voiture et de l'évènement FREINE.

II.2.1) Créer sa propre classe EventArgs

Nous devons tout d'abord nous créer notre propre classe EventArgs, qui tient compte des particularités de notre évènement. Faisons la dans un module de classe appelé VoitEventArgs.vb

Public Class VoitEventArgs
   Inherits System.EventArgs
Public type_freinage As String 'pluie, etc
   Public vitesse_fr As Integer 'vitesse au moment de freiner

   Public Sub New( )
   End Sub

Public Sub New(ByVal type_fr As String)
Me.type_freinage = type_fr
End Sub

End Class

Notre classe VoitEventArgs hérite de la classe System.EventArgs, bien sûr.

Puis nous avons les 2 propriétés type_freinage et vitesse_fr, qui vont donner au programmeur des renseignements sur l'évènement FREINE. Enfin nous avons 2 constructeurs de la classe. L'objet e nous concernant sera donc une instanciation de la classe VoitEventArgs.

II.2.2) Créer une classe EmetEvent

Créons cette classe dans un module de classe EmetEvent.vb .
Cette classe servira à créer un objet émetteur d'évènement. Cet objet sera utilisé pour émettre l'évènement FREINE. Et un de ses membres sera un event FREINE.
On ne peut émettre des évènements qu'à partir de la classe qui contient le membre event. C'est pour cela que pour émettre des évènements FREINE, nous prévoirons des méthodes à l'intérieur de l'objet émetteur d'évènements. Ainsi la méthode emet_freine_pluie émet un évènement FREINE, avec un e.type_freinage à "pluie".
On pourra appeler cet méthode de n'importe où, donc émettre des évènements de n'importe où.

Le constructeur de EmetEvent commence par créer un objet e_voit( une des propriétés de EmetEvent).

VoitEventHandler est en réalité une classe qui hérite de la classe System.EventHandler . Les objets EventHandler contiennent les adresses des procédures liées aux évènements. Ainsi le framework saura quelles méthodes appeler dans le cas du déclenchement de l'évènement.
Les procédures liées mises dans les objets de la classe EventHandler doivent avoir obligatoirement 2 paramètres: un sender de type object, et un objet e d'une classe dérivée de la classe EventsArgs. Et ces procédures doivent être des sub, par conséquent ne rien retourner.

Cependant, le VoitEventHandler est déclaré dans la classe comme une procédure "déléguée". Et on fait une sorte de déclaration de son prototype. Cette notion de déléguée est juste une vue de l'esprit, pour simplifier les choses. VoitEventHandler n'est pas une procédure en réalité, mais un objet( quand la classe sera instanciée) contenant toutes les adresses des procédures liées. On peut voir VoitEventHandler comme UNE procédure déléguée, représentant toutes les procédures liées. Et on déclare ainsi le prototype de cette procédure déléguée. Grâce à cet déclaration de prototype, le framework saura le prototype de toutes les procédures liées( qui auront toutes ce prototype).
Je vous conseille de voir l'objet de la classe VoitEventHandler comme un objet de la classe System.EventHandler( un 'traiteur' d'évènements ); et de ne pas voir VoitEventHandler comme une procédure, car ce n'en est pas une. D'ailleurs les membres event, tel FREINE, sont déclarés comme des objets de la classe EventHandler( dans notre cas de la classe VoitEventHandler).

On déclare ensuite un membre event. Event n'est pas un type, c'est un genre de membre. Il y a les attributs, les méthodes, et les events! . On appelle cet event: FREINE. Cet event est un objet de la classe VoitEventHandler. Ainsi, un évènement, est juste un objet traiteur d'évènements, qui contient les références de toutes les procédures liées. Ce qui est logique. Attention, en Visual Basic, les membres event, même public, ne sont pas visibles( par exemple en utilisant intellisense, vous ne les verrez pas). Mais ils sont tout-de-même présents.

Enfin, on se prévoit des méthodes, telles emet_freine_pluie, qui sauront capables d'émettre des évènements de n'importe où dans notre programme. Et avec un objet e rempli d'une manière qui nous arrange. Emet_freine_pluie, par exemple, non seulement émet un évènement FREINE, mais en plus fournit un e avec le champ e.type_freinage = "pluie". On pourra appeler par exemple emet_freine_pluie à partir de la form1!

   RaiseEvent est spécifique à VB. Il permet de déclencher un évènement, ici FREINE.

Public Class EmetEvent
   Public Delegate Sub VoitEventHandler(ByVal sender As Object, ByVal e As VoitEventArgs)
   Public Event FREINE As VoitEventHandler
   Public e_voit As VoitEventArgs = New VoitEventArgs( )
   Public Sub New( )
   End Sub

   Public Sub emet_freine_pluie(ByVal sender As Object)
e_voit.type_freinage = "pluie"
RaiseEvent FREINE(sender, Me.e_voit)
   End Sub

   Public Sub emet_freine_soleil(ByVal sender As Object)
e_voit.type_freinage = "soleil"
RaiseEvent FREINE(sender, Me.e_voit)
   End Sub
End Class

II.2.3) Les déclarations à l'extérieur

- Se créer un objet émetteur d'évènement, de la classe EmetEvent, par exemple comme attribut de la classe Form1.

Public WithEvents Emetteur_Ev_Voit As New EmetEvent( )

Il est nécessaire de déclarer en WithEvents l'objet Emetteur_Ev_Voit. Etant donné que c'est un objet capable de déclencher des évènements, VB .net oblige à le déclarer avec le mot clé 'WithEvents'.

Puis, dans le form1_load(ou autre), si cela n'a pas été fait comme ci-dessus::

this.Emetteur_Ev_Voit = new EmetEvent( );

- Dans le cas où vous souhaitez lier "à la main" votre procédure, sans utiliser le "handles" de VB( sinon ne faites rien):

Dans le form1_load, par exemple, ajouter notre évènement à notre objet de la classe VoitEventHandler( donc au membre event FREINE).

AddHandler Emetteur_Ev_Voit.FREINE, AddressOf Me.ma_sub_liee

On ajoute( "Add") à notre membre FREINE, qui est un objet VoitEventHandler, l'adresse de la procédure liée, c'est donc un pointeur de procédure.
Vous pouvez ajouter, de cette manière, autant de procédures liées que vous le souhaitez.

- Ensuite, on peut déclencher les évènements comme bon nous semble, en appelant les méthodes de la classe EmetEvent

Me.Emetteur_Ev_Voit.emet_freine_pluie(Me)

le 'Me' en paramètre correspond au formulaire principal de la classe form1, dans mon exemple. On aurait pu mettre la voiture qui freine.

- Et bien sûr, il faut se faire ses procédures liées, exactement de la même manière que pour les évènements windows.

Public Sub ma_sub_liee(ByVal sender As System.Object, ByVal e As VoitEventArgs) Handles Emetteur_Ev_Voit.FREINE
   Console.WriteLine("1 évènement émis")
   Console.WriteLine("e.type_freinage: " & e.type_freinage)
   Console.WriteLine("le sender est:" & sender.ToString( ))
End Sub

RETOUR HAUT