Présentation des événements

Précédent

Les événements sont, comme les délégués, un mécanisme de liaison tardive. En fait, les événements sont basés sur la prise en charge linguistique des délégués.

Les événements permettent à un objet de diffuser (à tous les composants intéressés du système) qu’un événement s’est produit. Tout autre composant peut s’abonner à l’événement et être averti lorsqu’un événement est déclenché.

Vous avez probablement utilisé des événements dans certaines de vos programmations. De nombreux systèmes graphiques ont un modèle d’événement pour signaler l’interaction utilisateur. Ces événements signalent le mouvement de la souris, les pressions sur les boutons et les interactions similaires. C’est l’un des scénarios les plus courants, mais pas le seul scénario où les événements sont utilisés.

Vous pouvez définir des événements qui doivent être déclenchés pour vos classes. Quand vous travaillez avec des événements, vous devez prendre en compte le fait qu’il se peut qu’aucun objet ne soit inscrit pour un événement particulier. Vous devez écrire votre code afin qu’il ne déclenche pas d’événements quand aucun écouteur n’est configuré.

L’abonnement à un événement crée également un couplage entre deux objets (la source de l’événement et le récepteur d’événements). Vous devez vérifier que le récepteur d’événements annule l’abonnement à la source de l’événement quand il n’est plus intéressé par les événements.

Objectifs de conception pour la prise en charge des événements

La conception de langage pour les événements cible ces objectifs :

• Activez un couplage minimal entre une source d’événement et un récepteur d’événements. Ces deux composants peuvent être écrits par différentes organisations et peuvent même être mis à jour selon des planifications différentes.
• Il doit être simple de s’abonner à un événement et de se désabonner de ce même événement.
• Les sources d’événements doivent prendre en charge plusieurs abonnés aux événements. Elles doivent aussi prendre en charge les scénarios où aucun abonné aux événements n’est attaché.

Vous pouvez voir que les objectifs des événements sont similaires aux objectifs des délégués. C’est pourquoi la prise en charge linguistique des événements repose sur la prise en charge linguistique des délégués.

Prise en charge linguistique des événements

La syntaxe de définition d’événements et d’abonnement ou de désinscrire des événements est une extension de la syntaxe pour les délégués.

Vous utilisez le mot clé event pour définir un événement :

public event EventHandler<FileFoundArgs>? FileFound;

Le type de l’événement (EventHandler<FileListArgs> dans cet exemple) doit être un type délégué. Il existe des conventions que vous devez suivre lors de la déclaration d’un événement. En général, le type délégué d’événement a un retour void. Les déclarations d’événement doivent être un verbe ou une locution verbale. Utilisez le passé lorsque l’événement signale quelque chose qui s’est produit. Utilisez un verbe tendu actuel (par exemple, Closing) pour signaler quelque chose qui est sur le point de se produire. Souvent, l'utilisation du présent indique que votre classe prend en charge un certain type de comportement de personnalisation. L’un des scénarios les plus courants consiste à prendre en charge l’annulation. Par exemple, un événement Closing peut inclure un argument qui indiquerait si l’opération de fermeture doit continuer ou non. D’autres scénarios permettent aux appelants de modifier le comportement en mettant à jour les propriétés des arguments d’événement. Vous pouvez déclencher un événement pour indiquer une action suivante proposée qu’un algorithme prendra. Le gestionnaire d’événements peut imposer une action différente en modifiant les propriétés de l’argument d’événement.

Lorsque vous souhaitez déclencher l’événement, vous appelez les gestionnaires d’événements à l’aide de la syntaxe d’appel de délégué :

FileFound?.Invoke(this, new FileFoundArgs(file));

Comme indiqué dans la section relative aux délégués , l’opérateur ?. permet d'éviter de déclencher l’événement lorsqu’il n’y a pas d’abonnés à cet événement.

Vous vous abonnez à un événement à l’aide de l’opérateur += :

var fileLister = new FileSearcher();
int filesFound = 0;

EventHandler<FileFoundArgs> onFileFound = (sender, eventArgs) =>
{
    Console.WriteLine(eventArgs.FoundFile);
    filesFound++;
};

fileLister.FileFound += onFileFound;

La méthode de gestionnaire a généralement le préfixe « On » suivi du nom de l’événement, comme indiqué dans le code précédent.

Vous vous désabonnez à l’aide de l’opérateur -= :

fileLister.FileFound -= onFileFound;

Il est important de déclarer une variable locale pour l’expression qui représente le gestionnaire d’événements. Cela garantit que le désabonnement supprime le gestionnaire. Si au lieu de cela vous utilisez le corps de l’expression lambda, vous essayez de supprimer un gestionnaire qui n’a jamais été attaché, ce qui ne fait rien.

Dans l’article suivant, vous allez en savoir plus sur les modèles d’événements classiques et différentes variantes de cet exemple.

Suivant