Événements (C# et Java)
Mise à jour : novembre 2007
Un événement est une façon pour une classe de notifier un objet aux utilisateurs lorsque quelque chose d'intéressant arrive à cet objet, par exemple un clic sur un contrôle dans une interface utilisateur graphique. Cette notification s'appelle déclencher un événement. L'objet qui déclenche un événement est appelé source ou expéditeur de l'événement.
Contrairement à la gestion des événements en Java, qui est effectuée par l'implémentation de classes d'écouteur personnalisées, les développeurs C# bénéficient de délégués pour la gestion d'événements. Un délégué est un type qui encapsule une méthode. Une fois qu'un délégué est initialisé avec une méthode, il se comporte exactement comme cette méthode et peut être appelé avec l'opérateur (). Cela est semblable à un pointeur fonction C++, mais de type sécurisé.
Le délégué peut être utilisé comme n'importe quelle autre méthode, avec des paramètres et une valeur de retour, comme dans cet exemple :
public delegate int ReturnResult(int x, int y);
Pour plus d'informations sur les délégués, consultez Délégués (Guide de programmation C#).
Les événements, comme les méthodes, ont une signature qui inclut un nom et une liste de paramètres. Cette signature est définie par un type délégué, par exemple :
public delegate void MyEventHandler(object sender, System.EventArgs e);
Dans la programmation d'interface utilisateur Windows, il est fréquent d'avoir le premier paramètre comme objet qui fait référence à la source de l'événement et le second comme objet qui contient des données en rapport avec l'événement. Toutefois, cette conception n'est pas requise ou mise en application par le langage C#. Une signature d'événement peut être identique à toute signature de délégué valide, tant qu'elle retourne une valeur void.
Un événement peut être déclaré à l'aide du mot clé event comme dans l'exemple suivant :
public event MyEventHandler TriggerIt;
Pour déclencher l'événement, définissez la méthode à appeler lorsque l'événement est déclenché comme dans l'exemple suivant :
public void Trigger()
{
TriggerIt();
}
Pour déclencher un événement, appelez le délégué et passez les paramètres en rapport avec l'événement. Le délégué appelle ensuite tous les gestionnaires qui ont été ajoutés à l'événement. Chaque événement peut avoir plusieurs gestionnaires assignés pour recevoir l'événement. Dans ce cas, l'événement appelle automatiquement chaque récepteur. Le déclenchement d'un événement nécessite un seul appel à l'événement, indépendamment du nombre de récepteurs.
Si vous souhaitez qu'une classe reçoive un événement, abonnez-vous à cet événement en ajoutant le délégué à l'événement à l'aide de l'opérateur +=, par exemple :
myEvent.TriggerIt += myEvent.MyMethod;
Pour annuler un abonnement à un événement, supprimez le délégué de l'événement en utilisant l'opérateur -= ; par exemple :
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod);
Pour plus d'informations sur les événements, consultez Événements (Guide de programmation C#).
.gif "Remarque") Remarque : |
|---|
En C# 2.0, les délégués peuvent encapsuler des méthodes nommées et des méthodes anonymes. Pour plus d'informations sur les méthodes anonymes, consultez Méthodes anonymes (Guide de programmation C#). |
Exemple
Description
L'exemple suivant définit un événement avec trois méthodes qui lui sont associées. Lorsque l'événement est déclenché, les méthodes sont exécutées. Puis une méthode est supprimée de l'événement et l'événement est encore déclenché.
Code
// Declare the delegate handler for the event:
public delegate void MyEventHandler();
class TestEvent
{
// Declare the event implemented by MyEventHandler.
public event MyEventHandler TriggerIt;
// Declare a method that triggers the event:
public void Trigger()
{
TriggerIt();
}
// Declare the methods that will be associated with the TriggerIt event.
public void MyMethod1()
{
System.Console.WriteLine("Hello!");
}
public void MyMethod2()
{
System.Console.WriteLine("Hello again!");
}
public void MyMethod3()
{
System.Console.WriteLine("Good-bye!");
}
static void Main()
{
// Create an instance of the TestEvent class.
TestEvent myEvent = new TestEvent();
// Subscribe to the event by associating the handlers with the events:
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod1);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod2);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod3);
// Trigger the event:
myEvent.Trigger();
// Unsuscribe from the the event by removing the handler from the event:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod2);
System.Console.WriteLine("\"Hello again!\" unsubscribed from the event.");
// Trigger the new event:
myEvent.Trigger();
}
}
Sortie
Hello!
Hello again!
Good-bye!
"Hello again!" unsubscribed from the event.
Hello!
Good-bye!