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 C# .Net 2005 > II Créer évènements

____________________________________________________________________________________________________

Connexion

II) CREER SES PROPRES EVENEMENTS EN C# .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 C# .net, mais aussi en C++ et en Visual Basic .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 void button1_Click(object sender, EventArgs e)

De plus, le code suivant est auto-généré lui-aussi, dans la fonction initializecomponent( ) de form1.Designer.cs :

this.button1.Click += new System.EventHandler(this.button1_Click);

Cette ligne permet de lier la fonction button1_Click à l'évenement Click du bouton 1. Nous l'expliquerons plus en détail bientôt.

Revenons à la ligne précédente:

private void button1_Click(object sender, EventArgs e) { }

Ceci est donc une fonction qui sera appelée en cas de click sur le bouton1. Cette fonction 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 fonction 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 dérivée de la classe System.EventArgs . Par exemple, dans le cas de l'évènement KeyDown:

private void Form1_KeyDown(object sender, KeyEventArgs e) { }

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 fonction 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.cs

namespace CreerEventCsharp {
class VoitEventArgs : EventArgs {
public string type_freinage; //pluie, etc
public int vitesse_fr; //vitesse au moment de freiner
public VoitEventArgs( ) { }
public VoitEventArgs(string type_fr) {
this.type_freinage = type_fr;
}
} //fin classe
} //fin namespace

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.cs .
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 fonctions liées aux évènements. Ainsi le framework saura quelles méthodes appeler dans le cas du déclenchement de l'évènement.
Les fonctions 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 fonctions ne doivent rien retourner( void).

Cependant, le VoitEventHandler est déclaré dans la classe comme une fonction "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 fonction en réalité, mais un objet( quand la classe sera instanciée) contenant toutes les adresses des fonctions liées. On peut voir VoitEventHandler comme UNE fonction déléguée, représentant toutes les fonctions liées. Et on déclare ainsi le prototype de cette fonction déléguée. Grâce à cet déclaration de prototype, le framework saura le prototype de toutes les fonctions 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 fonction, 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 fonctions liées. Ce qui est logique.

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!

namespace CreerEventCsharp {
   class EmetEvent {
private VoitEventArgs e_voit;

   public delegate void VoitEventHandler(object sender, VoitEventArgs e);
   public event VoitEventHandler FREINE;
   public void EmetEvent( ){
this.e_voit = new VoitEventArgs(); }
public void emet_freine_pluie( object sender){

this.e_voit.type_freinage = "pluie"; this.FREINE( sender, this.e_voit ); }

} //Fin classe

} //Fin namespace

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 EmetEvent Emetteur_Voit

Puis, dans le form1_load(ou autre):

this.Emetteur_voit = new EmetEvent( );

- Dans le form1_load, par exemple, ajouter notre évènement à notre objet de la classe VoitEventHandler

this.Emetteur_voit.FREINE += new EmetEvent.VoitEventHandler( ma_fct_liee);

Ceci se fait avec une syntaxe spécial( "+=" ), qui a un sens particulier ici. On "ajoute" à notre membre FREINE, qui est un objet VoitEventHandler, un nouvel objet VoitEventHandler. Ce nouvel objet est initialisé avec un constructeur à 1 paramètre. Le paramètre est l'adresse de la fonction liée, c'est donc un pointeur de fonction: il suffit donc d'écrire le nom de la fonction liée, et C# comprendra qu'il doit donner la référence, car les fonctions se passent par référence..
Tout ceci est une syntaxe spéciale, que visual studio comprendra, et il comprendra que vous voulez ajouter cet fonction à votre objet VoitEventHandler. Vous pouvez ajouter, de cette manière, autant de fonctions liées que vous le souhaitez. Et vous pouvez aussi utiliser le "-=" pour en retirer.
Remarque: cette syntaxe est utilisée dans les lignes auto-générées par visual studio dans la classe form1, dans la méthode initializecomponent, pour lier vos fonctions aux évènements windows( par exemple votre fonction button1_click).

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

this.Emetteur_voit.emet_freine_pluie(this);

le this 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.

void ma_fct_liee( object sender, VoitEventArgs e ) {

this.textBox1.Text = "1 event FREINE emis. e.text:=' " + e.type_freinage + " ' . sender: " + sender.ToString();
}

RETOUR HAUT