Les événements

Définition
Les concepts liés aux événements
     Les abonnés
     L'événement lui-même
Exemple
     Définition des arguments d'événements
     Déclaration d'un délégué
     Déclaration des événements
     Définition des abonnés
     Raccordement aux événements

Définition

D'une façon générale, nous pouvons définir un événement comme un stimulus qui provoque une réaction. Dans le cas d'une interface graphique, le stimulus peut provenir d'une interaction entre un utilisateur (qui par exemple, clique sur un bouton) et l'interface. Les réactions peuvent être très variées: enregistrement d'un fichier, affichage d'une fenêtre, téléchargement d'un document, etc.
Les événements sont très utilisés dans les interfaces graphiques mais plus généralement, ils permettent de notifier un changement d'état. Pour aborder cette partie, il est nécessaire d'avoir assimilé le concept de délégué.

Les concepts liés aux événements

La mécanisme d'événement se décompose en deux concepts: les abonnés à l'événement et l'événement lui-même.

Les abonnés

Un abonné à un événement est prévenu à chaque fois que l'événement est déclenché. Concrètement, un abonné est une méthode qui renvoie le type void et qui possède deux arguments.
Le premier argument, de type object, se nomme sender. Il permet à l'abonné d'un événement de connaître précisément l'instance de l'objet qui a émis l'événement.
Le second argument est de type System.EventArgs. Cette classe représente la classe de base pour les classes personnalisées qui contiennent des données d'événement.

L'événement lui-même

Un événement est un membre d'une classe que l'on déclare avec le mot-clé event et à l'aide d'un délégué. Un événement est plus précisément une instance d'un délégué. Le rôle du délégué est d'encapsuler les méthodes abonnées.

Exemple

Et maintenant, rien de mieux qu'un exemple pour détailler l'implantation d'un événement.
Nous considérons un zoo ainsi qu'un responsable pour chaque famille d'animaux. Le choix d'un responsable est purement arbitraire ! L'essentiel est de fournir un exemple simple à comprendre pour illustrer le mécanisme des événements.
L'événement correspond ici à la naissance d'un animal. L'idée est simple: le responsable est appelé lorsqu'une naissance a lieu dans la famille dont il a la charge.
Pour faire la totale, nous développons également une classe personnalisée pour nos arguments d'événements.
Commençons donc par le commencement, en procédant étape par étape !

Définition des arguments d'événements

D'une façon générale, pour créer nos propres arguments d'événements, il nous faut créer une classe qui dérive de la classe System.EventArgs. Nous déclarons donc une classe NaissanceEventArgs qui hérite de EventArgs.
Cette classe contient:

• Une méthode publique InfoNaissance qui renvoie une chaîne de caractères, le nom de l'animal.
• Un constructeur qui initialise le nom de l'animal.

class NaissanceEventArgs: EventArgs
{
	private string animal;

	public string InfoNaissance()
	{
		return animal;
	}

	public NaissanceEventArgs(string Animal)
	{
		animal = Animal;
	}
}						

Déclaration des délégués

Nous souhaitons créer un événement. Puisqu'un événement est une instance de délégué, nous devons d'abord déclarer un délégué:

public delegate void NaissanceEventHandler(object sender, EventArgs e);

Remarque
Pour nommer ses délégués, le .NET Framework utilise la convention suivante: xxxEventHandler.
Nous adoptons le même plan de nommage. Cependant, le programmeur est libre de choisir le nom de ses délégués.

Déclaration des événements

Nous déclarons maintenant deux événements NaissanceRuminant et NaissanceFelide dans une classe Zoo.
Les méthodes NRuminant et NFelide permettent respectivement de déclencher les événements NaissanceRuminant et NaissanceFelide. Ces événements peuvent maintenant être utilisés comme des champs. Il est nécessaire de tester ces champs dans nos méthodes de déclenchement. Par exemple, dans la méthode NRuminant, nous testons le champ NaissanceRuminant. Si nous raccordons notre délégué NaissanceEventHandler à notre événement NaissanceRuminant alors NaissanceRuminant fait référence à NaissanceEventHandler. Dans le cas contraire, c'est-à-dire s'il n'existe aucun raccord, NaissanceRuminant vaut null.
D'une façon générale:

Si un délégué D est raccordé à un événement E alors E fait référence à D.
Si aucun délégué n'est raccordé à événement E alors E vaut null.

class Zoo
{
	public event NaissanceEventHandler NaissanceRuminant;
	public event NaissanceEventHandler NaissanceFelide;

	public void NRuminant(NaissanceEventArgs ne)
	{
		if (NaissanceRuminant != null)
			NaissanceRuminant(this, ne);
	}

	public void NFelide(NaissanceEventArgs ne)
	{
		if (NaissanceFelide != null)
			NaissanceFelide(this, ne);
	}
}						

Définition des abonnés

Nous déclarons une classe Responsable dans laquelle nous définissons la méthode SignalerNaissance. C'est cette méthode que nous allons abonner à nos événements NaissanceRuminant et NaissanceFelide.

class Responsable
{
	private string Nom;

	public Responsable(string nom)
	{
		Nom = nom;
	}

	public void SignalerNaissance(object sender, EventArgs e)
	{
		if (e != null)
		{
			Console.Write(Nom);
			Console.Write(" est appele(e) pour la naissance suivante: ");
			Console.WriteLine( ((NaissanceEventArgs)e).InfoNaissance() );
		}
	}
}						

Remarque
À la dernière ligne de code, nous sommes obligés de faire ce que l'on nomme un cast. Nous devons rajouter (NaissanceEventArgs) devant e pour indiquer qu'il s'agit de notre type d'événement personnalisé NaissanceEventArgs et non du type d'événement par défaut EventArgs.

Raccordement aux événements

Il ne reste plus qu'à raccorder notre délégué NaissanceEventHandler à nos événements NaissanceRuminant et NaissanceFelide. Pour réaliser cette tâche, nous utilisons l'opérateur +=. L'accès à un événement se fait de la même façon que l'accès à un champ. Ainsi, à la ligne

MonZoo.NaissanceRuminant += new NaissanceEventHandler(Alan.SignalerNaissance);

nous raccordons le délégué NaissanceEventHandler au champ NaissanceRuminant. Il en est de même pour la ligne du dessous avec le champ NaissanceFelide. Pour supprimer un délégué d'un champ, nous utilisons l'opérateur -=.
Nous pouvons maintenant utiliser nos méthodes de déclenchement d'(heureux) événements pour signaler à Alan et Julie la naissance d'une girafe et de trois lynx !

class MaClasse
{
	public static void Main()
	{
		Zoo MonZoo = new Zoo();

		Responsable Alan = new Responsable("Alan");
		Responsable Julie = new Responsable("Julie");

		MonZoo.NaissanceRuminant += new NaissanceEventHandler(Alan.SignalerNaissance);
		MonZoo.NaissanceFelide += new NaissanceEventHandler(Julie.SignalerNaissance);

		// Déclenchement des événements
		MonZoo.NRuminant( new NaissanceEventArgs("une girafe."));
		MonZoo.NFelide( new NaissanceEventArgs("trois lynx."));
	}
}						

Voici l'intégralité du code: event1.cs
Et le résultat du programme:

Les événements sur les MSDN

Mercredi 20 Juillet 2005