Partager via

Gérer et déclencher des événements

Les événements dans .NET sont basés sur le modèle délégué. Le modèle délégué suit le modèle de conception de l’observateur, qui permet à un abonné de s’inscrire auprès d’un fournisseur et de recevoir des notifications. Un expéditeur d’événement envoie une notification lorsqu’un événement se produit. Un récepteur d’événements définit la réponse. Cet article décrit les principaux composants du modèle délégué, comment consommer des événements dans des applications et comment implémenter des événements dans votre code.

Déclencher des événements avec un générateur d’événements

Un événement est un message envoyé par un objet pour signaler l’occurrence d’une action. L’action peut être une interaction utilisateur, telle qu’une pression sur bouton, ou elle peut résulter d’une autre logique de programme, telle qu’une modification de valeur de propriété. L’objet qui déclenche l’événement est appelé expéditeur de l’événement. L’expéditeur de l’événement ne connaît pas l’objet ou la méthode qui reçoit (gère) les événements qu’il déclenche. L’événement est généralement une composante de l’expéditeur de l’événement. Par exemple, l’événement Click est membre de la Button classe et l’événement PropertyChanged est membre de la classe qui implémente l’interface INotifyPropertyChanged .

Pour définir un événement, vous utilisez l’événement C# ou le mot clé d’événement Visual Basic dans la signature de votre classe d’événements et spécifiez le type de délégué de l’événement. Les délégués sont décrits dans la section suivante.

En règle générale, pour déclencher un événement, vous ajoutez une méthode marquée comme protected et virtual (en C#) ou ProtectedOverridable (en Visual Basic). La convention de nommage pour la méthode est On<EventName>, par exemple OnDataReceived. La méthode doit prendre un paramètre qui spécifie un objet de données d’événement, qui est un objet de type EventArgs ou un type dérivé. Vous fournissez cette méthode pour permettre aux classes dérivées de remplacer la logique pour déclencher l’événement. Une classe dérivée doit toujours appeler la On<EventName> méthode de la classe de base pour s’assurer que les délégués inscrits reçoivent l’événement.

L’exemple suivant montre comment déclarer un événement nommé ThresholdReached. L’événement est associé au EventHandler délégué et déclenché dans une méthode nommée OnThresholdReached:

class Counter
{
    public event EventHandler ThresholdReached;

    protected virtual void OnThresholdReached(EventArgs e)
    {
        ThresholdReached?.Invoke(this, e);
    }

    // provide remaining implementation for the class
}

Public Class Counter
    Public Event ThresholdReached As EventHandler

    Protected Overridable Sub OnThresholdReached(e As EventArgs)
        RaiseEvent ThresholdReached(Me, e)
    End Sub

    ' provide remaining implementation for the class
End Class

Déclarer des signatures de délégué pour les gestionnaires d’événements

Un délégué est un type qui contient une référence à une méthode. Un délégué est déclaré avec une signature qui affiche le type de retour et les paramètres des méthodes qu’il référence. Elle ne peut contenir que des références aux méthodes qui correspondent à sa signature. Un délégué équivaut à un pointeur de fonction de type sécurisé ou à un rappel. Une déclaration de délégué est suffisante pour définir une classe de délégué.

Les délégués ont de nombreuses utilisations dans .NET. Dans le contexte des événements, un délégué est un intermédiaire (ou mécanisme de type pointeur) entre la source d’événement et le code qui gère l’événement. Vous associez un délégué à un événement en incluant le type de délégué dans la déclaration d’événement, comme illustré dans l’exemple de la section précédente. Pour plus d’informations sur les délégués, consultez la Delegate classe.

.NET fournit les délégués EventHandler et EventHandler<TEventArgs> pour prendre en charge la plupart des scénarios d’événements. Utilisez le EventHandler délégué pour tous les événements qui n’incluent pas de données d’événement. Utilisez le EventHandler<TEventArgs> délégué pour les événements qui incluent des données sur l’événement. Ces délégués n’ont aucune valeur de type de retour et prennent deux paramètres (un objet pour la source de l’événement et un objet pour les données d’événement).

Les délégués sont des objets de classe multicast, ce qui signifie qu’ils peuvent contenir des références à plusieurs méthodes de gestion d'événements. Pour plus d’informations, consultez la Delegate page de référence. Les délégués offrent une flexibilité et un contrôle affiné dans la gestion des événements. Un délégué agit comme répartiteur d’événements pour la classe qui déclenche l’événement en conservant une liste de gestionnaires d’événements inscrits pour l’événement.

Utilisez les types de délégués EventHandler et EventHandler<TEventArgs> pour définir le délégué nécessaire. Vous marquez un délégué par le type delegate en C# ou par le type Delegate en Visual Basic dans la déclaration. L’exemple suivant montre comment déclarer un délégué nommé ThresholdReachedEventHandler:

public delegate void ThresholdReachedEventHandler(object sender, ThresholdReachedEventArgs e);

Public Delegate Sub ThresholdReachedEventHandler(sender As Object, e As ThresholdReachedEventArgs)

Utiliser des classes de données d’événement

Les données associées à un événement peuvent être fournies via une classe de données d’événement. .NET fournit de nombreuses classes de données d’événements que vous pouvez utiliser dans vos applications. Par exemple, la SerialDataReceivedEventArgs classe est la classe de données d’événement pour l’événement SerialPort.DataReceived . .NET suit un modèle de nommage où toutes les classes de données d’événement se terminent par le EventArgs suffixe. Vous déterminez la classe de données d’événement associée à un événement en examinant le délégué de l’événement. Par exemple, le SerialDataReceivedEventHandler délégué inclut la SerialDataReceivedEventArgs classe comme paramètre.

La EventArgs classe est généralement le type de base pour les classes de données d’événement. Vous utilisez également cette classe si un événement n’a pas de données associées. Lorsque vous créez un événement qui informe les abonnés qu’un événement s’est produit sans aucune donnée supplémentaire, incluez la EventArgs classe comme deuxième paramètre dans le délégué. Vous pouvez transmettre la EventArgs.Empty valeur lorsqu’aucune donnée n’est fournie. Le EventHandler délégué inclut la classe EventArgs en tant que paramètre.

Vous pouvez créer une classe qui dérive de la EventArgs classe pour fournir tous les membres nécessaires pour transmettre des données liées à l’événement. En règle générale, vous devez utiliser le même modèle de nommage que .NET et mettre fin à votre nom de classe de données d’événement avec le EventArgs suffixe.

L’exemple suivant montre une classe de données d’événement nommée ThresholdReachedEventArgs qui contient des propriétés spécifiques à l’événement déclenché :

public class ThresholdReachedEventArgs : EventArgs
{
    public int Threshold { get; set; }
    public DateTime TimeReached { get; set; }
}

Public Class ThresholdReachedEventArgs
    Inherits EventArgs

    Public Property Threshold As Integer
    Public Property TimeReached As DateTime
End Class

Répondre aux événements avec des gestionnaires

Pour répondre à un événement, vous définissez une méthode de gestionnaire d’événements dans le récepteur d’événements. Cette méthode doit correspondre à la signature du délégué pour l’événement que vous gérez. Dans le gestionnaire d’événements, vous effectuez les actions requises lorsque l’événement est déclenché, par exemple la collecte de l’entrée utilisateur après que l’utilisateur appuie sur un bouton. Pour recevoir des notifications lorsque l’événement se produit, votre méthode de gestionnaire d’événements doit s’abonner à l’événement.

L’exemple suivant montre une méthode de gestionnaire d’événements nommée c_ThresholdReached qui correspond à la signature du EventHandler délégué. La méthode s’abonne à l’événement ThresholdReached :

class ProgramTwo
{
    static void Main()
    {
        var c = new Counter();
        c.ThresholdReached += c_ThresholdReached;

        // provide remaining implementation for the class
    }

    static void c_ThresholdReached(object sender, EventArgs e)
    {
        Console.WriteLine("The threshold was reached.");
    }
}

Module Module1

    Sub Main()
        Dim c As New Counter()
        AddHandler c.ThresholdReached, AddressOf c_ThresholdReached

        ' provide remaining implementation for the class
    End Sub

    Sub c_ThresholdReached(sender As Object, e As EventArgs)
        Console.WriteLine("The threshold was reached.")
    End Sub
End Module

Utiliser des gestionnaires d’événements statiques et dynamiques

.NET permet aux abonnés de s’inscrire aux notifications d’événements de manière statique ou dynamique. Les gestionnaires d’événements statiques sont actifs pendant toute la durée de vie de la classe dont ils gèrent les événements. Les gestionnaires d’événements dynamiques sont explicitement activés et désactivés pendant l’exécution du programme, généralement en réponse à une logique de programme conditionnel. Vous pouvez utiliser des gestionnaires dynamiques lorsque les notifications d’événements sont nécessaires uniquement dans certaines conditions ou lorsque les conditions d’exécution déterminent le gestionnaire spécifique à appeler. L’exemple de la section précédente montre comment ajouter dynamiquement un gestionnaire d’événements. Pour plus d’informations, consultez Événements (en Visual Basic) et Événements (en C#).

Déclencher plusieurs événements

Si votre classe déclenche plusieurs événements, le compilateur génère un champ par instance de délégué d’événement. Si le nombre d’événements est important, le coût de stockage d’un champ par délégué peut ne pas être acceptable. Pour ces scénarios, .NET fournit des propriétés d’événement que vous pouvez utiliser avec une autre structure de données de votre choix pour stocker les délégués d’événements.

Les propriétés d'événements sont constituées de déclarations d'événements accompagnées par des accesseurs d'événements. Les accesseurs d’événements sont des méthodes que vous définissez pour ajouter ou supprimer des instances de délégué d’événement de la structure de données de stockage.

Note

Les propriétés d’événement sont plus lentes que les champs d’événement, car chaque délégué d’événement doit être récupéré avant de pouvoir être appelé.

Le compromis est entre la mémoire et la vitesse. Si votre classe définit de nombreux événements rarement déclenchés, vous devez implémenter des propriétés d’événement. Pour plus d’informations, consultez Gérer plusieurs événements à l’aide des propriétés d’événement.

Les ressources suivantes décrivent d’autres tâches et concepts liés au travail avec les événements :

Revoir les références des spécifications

La documentation de référence sur les spécifications est disponible pour les API qui prennent en charge la gestion des événements :

Nom de l’API Type de l’API Reference
EventHandler Déléguer EventHandler
EventHandler<TEventArgs> Déléguer EventHandler<TEventArgs>
EventArgs classe EventArgs
Déléguer classe Delegate

Contenu connexe

  • Last updated on