Comprendre l'événement C#

Les événements en C# sont un concept fondamental que de nombreux développeurs utilisent mais qu'ils ne comprennent pas toujours parfaitement, en particulier lorsqu'il s'agit de créer leurs propres événements. Tim Corey fournit un guide complet sur la création et l'utilisation d'événements, explorant les meilleures pratiques et les fonctionnalités avancées dans sa vidéo "Événements C# - Création et consommation d'événements dans votre application".

Dans cet article, nous allons explorer les événements C#, en nous concentrant sur leur syntaxe, leur définition et la manière dont ils permettent de résoudre des problèmes de programmation courants, à l'aide des exemples vidéo de Tim Corey. Comprendre la gestion des événements en C# est essentiel pour créer des applications réactives, et cet article vous aidera à saisir les concepts fondamentaux de la journalisation des erreurs personnalisées, de la gestion des exceptions et de la programmation axée sur les événements.

Introduction aux événements

En C# et dans les langages de programmation, les événements jouent un rôle essentiel dans la programmation pilotée par les événements, permettant aux applications de répondre à des actions telles que les interactions de l'utilisateur ou les changements du système. Par rapport à d'autres langages de programmation, C# offre une approche structurée de la gestion des événements, ce qui le rend idéal pour les applications rapides et de petite taille. Les événements en C# sont déclenchés par des actions spécifiques, et ces actions invoquent les gestionnaires d'événements correspondants pour effectuer les tâches souhaitées.

Tim commence par expliquer que la plupart des développeurs connaissent les événements en C#, mais ne savent pas forcément comment créer des événements personnalisés. L'objectif de la vidéo est de présenter les événements, d'expliquer la création d'événements personnalisés, de discuter de leurs caractéristiques et d'exposer les meilleures pratiques.

Démonstration d'une application

Tim utilise une simple application bancaire construite avec Windows Forms (WinForms) pour démontrer les événements. L'application simule les opérations bancaires de base d'un client, notamment la consultation des soldes et l'enregistrement des transactions.

1. Vue d'ensemble de l'application :

   • L'application comporte deux formulaires : l'un pour afficher le solde des comptes et les transactions, l'autre pour enregistrer les nouvelles transactions.
   • Il comprend des boutons permettant de simuler des achats par carte de crédit et de gérer les découverts en transférant des fonds de l'épargne vers le compte courant.

2. Formulaire principal :

   • Affiche le nom du client, le solde de son compte courant et de son compte d'épargne.
   • Affiche les listes de transactions pour les deux comptes.
   • Contient un bouton permettant d'ouvrir le formulaire d'enregistrement de la transaction.

3. Formulaire de transaction :

   • Permet à l'utilisateur de saisir des montants de transaction.
   • Simule des achats et gère les découverts en transférant des fonds de l'épargne vers le compte courant.

Code de l'application de démonstration

Tim explique le code backend de l'application bancaire de démonstration :

1. Clientèle :

   • Représente un client avec des propriétés pour le nom du client et deux comptes (chèque et épargne).
   • La classe Customer est simple mais constitue un bon point de départ pour comprendre comment gérer plusieurs comptes.

2. Classe de compte :

   • Gère les détails d'un compte bancaire, y compris le nom du compte, le solde et la liste des transactions.
   • La propriété Balance est de type décimal pour des calculs monétaires précis.
   • La propriété Transactions est une liste en lecture seule afin d'éviter toute modification externe.

3. Gestion des dépôts et des paiements :

   • Méthode AddDeposit : Ajoute un dépôt au compte, met à jour le solde et enregistre la transaction.
   • Méthode de paiement : gère les retraits, notamment en vérifiant que les fonds sont suffisants et en gérant la protection contre les découverts en transférant des fonds à partir d'un compte de secours si nécessaire.

4. Protection contre les découverts :

   • L'application comprend une logique de gestion des découverts. Si le solde du compte courant est insuffisant pour une transaction, l'application consulte le compte d'épargne pour couvrir le déficit. Si le solde combiné est suffisant, il transfère le montant requis sur le compte courant et termine la transaction.

Pour les exemples de code, vous pouvez vous référer directement à la vidéo de Tim Corey où il explique le code de 3:18 à 18:27.

Événement : Clic de bouton

Dans cette section, Tim Corey s'est plongé dans le fonctionnement des événements de clic de bouton dans Windows Forms, expliquant comment ces événements sont câblés et comment ils fonctionnent.

Compréhension des événements liés au clic sur un bouton

Tim commence par expliquer le concept familier des événements de clics de boutons dans les applications Windows Forms. Lorsque vous double-cliquez sur un bouton dans le concepteur, Visual Studio génère automatiquement une méthode de gestion d'événement pour l'événement de clic.

1. Méthode du gestionnaire d'événements :

   • Cette méthode est appelée chaque fois que l'on clique sur le bouton. C'est l'endroit où vous placez le code qui doit être exécuté en réponse au clic sur le bouton.
   private void recordTransactionButton_Click(object sender, EventArgs e)
   {
       // Code to handle the button click event
   }

   C#

2. Câblage de l'événement :

   • La méthode de gestion d'événement est reliée à l'événement de clic sur le bouton dans le fichier de conception du formulaire (FormName.Designer.cs). Pour ce faire, on utilise l'opérateur += pour ajouter le gestionnaire d'événement à l'événement de clic du bouton.
   this.recordTransactionButton.Click += new System.EventHandler(this.recordTransactionButton_Click);

   AddHandler Me.recordTransactionButton.Click, AddressOf Me.recordTransactionButton_Click

   C#VB

Création et invocation d'événements personnalisés

Tim explique comment créer des événements personnalisés en C#, en commençant par la classe Compte où les événements seront déclenchés.

1. Définir un événement :

   • Un événement est défini à l'aide du mot-clé event. Elle ressemble à une variable publique, mais elle est spécifiquement destinée aux événements.
   public event EventHandler<string> RaiseTransactionApprovedEvent;

   Public Event RaiseTransactionApprovedEvent As EventHandler(Of String)

   C#VB

2. Déclencher l'événement :

   • Les événements sont déclenchés à l'aide de la méthode Invoke, généralement dans la classe qui définit l'événement. La méthode Invoke prend deux paramètres : l'expéditeur (généralement this) et les données d'événement (dans ce cas, une chaîne).
   private void OnTransactionApproved(string transactionName)
   {
       RaiseTransactionApprovedEvent?.Invoke(this, transactionName);
   }

   C#

3. Câblage et gestion des événements :

   • Abonnez-vous à l'événement à l'aide de l'opérateur += et définissez une méthode pour gérer l'événement lorsqu'il est levé.
   account.RaiseTransactionApprovedEvent += Account_RaiseTransactionApprovedEvent;
   
   private void Account_RaiseTransactionApprovedEvent(object sender, string e)
   {
       // Code to handle the event
   }

   C#

Utilisation d'événements pour mettre à jour l'interface utilisateur

Tim explique comment utiliser les événements pour mettre automatiquement à jour l'interface utilisateur du navigateur lorsque certaines actions se produisent, par exemple lorsqu'une transaction est approuvée.

1. Événements de sensibilisation :

   • Déclenchez l'événement personnalisé après l'approbation d'une transaction.
   public void AddDeposit(decimal amount, string depositName)
   {
       // Code to add deposit
       RaiseTransactionApprovedEvent?.Invoke(this, depositName);
   }

   C#

2. Souscription aux événements dans l'interface utilisateur :

   • Abonnez-vous à l'événement dans le formulaire principal pour mettre à jour la liste des transactions chaque fois qu'une nouvelle transaction est approuvée.
   public MainForm()
   {
       InitializeComponent();
       account.RaiseTransactionApprovedEvent += Account_RaiseTransactionApprovedEvent;
   }
   
   private void Account_RaiseTransactionApprovedEvent(object sender, string e)
   {
       // Update the UI with the new transaction
   }

   C#

Event ?.Invoke() expliqué

Tim Corey explique l'utilisation de la syntaxe ?.Invoke() lors de la levée d'événements en C#. Cette approche moderne simplifie le code et garantit la sécurité des threads.

L'opérateur point d'interrogation

Le point d'interrogation ( ?.) devant Invoke est un opérateur conditionnel nul. Il vérifie si le gestionnaire d'événements est nul avant de l'invoquer, ce qui permet d'éviter les exceptions potentielles.

1. Approche traditionnelle :

   • Auparavant, les développeurs utilisaient plusieurs lignes de code pour vérifier si le gestionnaire d'événements était nul, puis l'invoquer.
   if (RaiseTransactionApprovedEvent != null)
   {
       RaiseTransactionApprovedEvent(this, depositName);
   }

   C#

2. Approche moderne avec ?.Invoke() :

   • L'opérateur null-conditional rationalise ce processus, en effectuant la vérification de la nullité et en invoquant l'événement en une seule ligne.
   RaiseTransactionApprovedEvent?.Invoke(this, depositName);

   RaiseTransactionApprovedEvent?.Invoke(Me, depositName)

   C#VB
   • Si RaiseTransactionApprovedEvent est null, l'invocation ne se poursuit pas, évitant ainsi effectivement toute exception.

3. Avantages :

   • Simplifie le code : Réduit la quantité de code nécessaire pour invoquer des événements en toute sécurité.
   • Thread Safety : élimine les conditions de course en vérifiant la présence de null et en invoquant l'événement en une seule étape.

Écouter et écrire du code pour l'événement

Tim explique comment écouter les événements personnalisés dans une application Windows Forms et mettre à jour l'interface utilisateur en conséquence.

1. S'inscrire à des événements :

   • Abonnez-vous à l'événement personnalisé à l'aide de l'opérateur +=.
   customer.CheckingAccount.TransactionApprovedEvent += CheckingAccount_TransactionApprovedEvent;

   AddHandler customer.CheckingAccount.TransactionApprovedEvent, AddressOf CheckingAccount_TransactionApprovedEvent

   C#VB

2. Méthode du gestionnaire d'événements :

   • Définissez une méthode pour gérer l'événement. Cette méthode met à jour l'interface utilisateur en fonction des données de l'événement.
   private void CheckingAccount_TransactionApprovedEvent(object sender, string e)
   {
       // Update the UI with the new transaction
       checkingTransactionsDataSource.DataSource = null;
       checkingTransactionsDataSource.DataSource = customer.CheckingAccount.Transactions;
       checkingBalanceLabel.Text = customer.CheckingAccount.Balance.ToString("C2");
   }

   C#

Création d'un événement personnalisé : L'événement en action et récapitulation

Tim montre l'ensemble du processus de création, d'augmentation et de gestion des événements personnalisés en action.

1. Déclencher l'événement :

   • Lancez l'événement après l'approbation d'une transaction ou lorsque le solde change.
   private void OnTransactionApproved(string transactionName)
   {
       RaiseTransactionApprovedEvent?.Invoke(this, transactionName);
   }

   C#

2. Gestion d'événements multiples :

   • Veillez à ce que l'application soit à l'écoute de plusieurs événements, tels que les transactions et les changements de solde, afin que l'interface utilisateur soit mise à jour en temps réel.
   public MainForm()
   {
       InitializeComponent();
       customer.CheckingAccount.TransactionApprovedEvent += CheckingAccount_TransactionApprovedEvent;
       customer.SavingsAccount.TransactionApprovedEvent += SavingsAccount_TransactionApprovedEvent;
   }
   
   private void SavingsAccount_TransactionApprovedEvent(object sender, string e)
   {
       // Update the UI with the new savings transaction
       savingsTransactionsDataSource.DataSource = null;
       savingsTransactionsDataSource.DataSource = customer.SavingsAccount.Transactions;
       savingsBalanceLabel.Text = customer.SavingsAccount.Balance.ToString("C2");
   }

   C#

3. Exécuter l'application :

   • Tim exécute l'application pour montrer comment l'interface utilisateur se met à jour automatiquement en fonction des événements déclenchés par les transactions.

Informations sur l'argument d'événement : Débogage

Tim montre comment déboguer les événements et inspecter les informations qu'ils envoient.

1. Établir un point d'arrêt :

   • Placez un point d'arrêt dans la méthode du gestionnaire d'événement pour inspecter les données de l'événement.
   private void CheckingAccount_TransactionApprovedEvent(object sender, string e)
   {
       // Breakpoint here
   }

   C#

2. Débogage :

   • Exécutez l'application et effectuez une transaction pour déclencher l'événement. Examinez les arguments de l'événement dans le débogueur.
   • Le paramètre sender fournit l'instance qui a déclenché l'événement, et le paramètre e contient les données de l'événement.

Création d'un autre événement personnalisé (événement de découvert)

Tim Corey développe la démo en créant un autre événement personnalisé pour gérer les situations de découvert. Cet événement sera déclenché lorsqu'un découvert se produit et notifiera à l'utilisateur le montant du découvert.

Définir l'événement de découvert

Tim commence par définir un nouvel événement dans la classe Compte pour les scénarios de découvert :

1. Déclaration d'événement :

   • Définissez l'événement à l'aide du mot-clé event et d'un type décimal pour transmettre le montant du découvert.
   public event EventHandler<decimal> OverdraftEvent;

   Public Event OverdraftEvent As EventHandler(Of Decimal)

   C#VB

2. Déclencher l'événement :

   • L'événement est déclenché dans la partie du code où un découvert se produit avec succès.
   if (overdraftSuccessful)
   {
       OverdraftEvent?.Invoke(this, overdraftAmount);
   }

   C#

Souscription à l'événement de découvert du côté du tableau de bord

1. Câblage de l'événement :

   • Abonnez-vous à l'événement de découvert dans le formulaire du tableau de bord.
   customer.CheckingAccount.OverdraftEvent += CheckingAccount_OverdraftEvent;

   AddHandler customer.CheckingAccount.OverdraftEvent, AddressOf CheckingAccount_OverdraftEvent

   C#VB

2. Gérer l'événement :

   • Définir un gestionnaire d'événements pour afficher un message lorsqu'un découvert se produit.
   private void CheckingAccount_OverdraftEvent(object sender, decimal e)
   {
       errorMessage.Text = $"You had an overdraft protection transfer of {e:C2}";
       errorMessage.Visible = true;
   }

   C#

3. Déclenchement et affichage de l'événement :

   • Lorsqu'un découvert se produit, l'événement se déclenche et met à jour l'interface utilisateur pour avertir l'utilisateur.
   You had an overdraft protection transfer of $20.44

   Text

Écouter l'événement à plusieurs endroits

Tim explique comment écouter le même événement dans plusieurs langues et sous plusieurs formes, démontrant ainsi la polyvalence des événements.

1. Ajouter une étiquette à un autre formulaire :

   • Ajouter une étiquette à un formulaire secondaire pour afficher les messages de découvert.
   <asp:Label ID="errorMessage" runat="server" Visible="false" />

   HTML

2. S'inscrire à l'événement :

   • S'abonner à l'événement de découvert dans le formulaire secondaire.
   customer.CheckingAccount.OverdraftEvent += SecondaryForm_OverdraftEvent;

   AddHandler customer.CheckingAccount.OverdraftEvent, AddressOf SecondaryForm_OverdraftEvent

   C#VB

3. Gérer l'événement :

   • Définir un gestionnaire d'événement pour afficher le message de découvert sur le formulaire secondaire.
   private void SecondaryForm_OverdraftEvent(object sender, decimal e)
   {
       errorMessage.Visible = true;
   }

   C#

4. Gestion simultanée d'événements :

   • Tim démontre que l'événement peut être traité simultanément sous plusieurs formes, ce qui garantit que toutes les parties pertinentes de l'application répondent à l'événement de manière appropriée.
   Both the main form and the secondary form display the overdraft message when the event is triggered.

   Text

Supprimer les écouteurs d'événements de la mémoire

Tim souligne l'importance de nettoyer les récepteurs d'événements afin d'éviter les fuites de mémoire et de garantir la bonne performance de l'application.

1. Désabonnement aux événements :

   • Il est essentiel de se désabonner des événements avant de détruire une instance de classe ou de fermer un formulaire.
   customer.CheckingAccount.OverdraftEvent -= CheckingAccount_OverdraftEvent;

   RemoveHandler customer.CheckingAccount.OverdraftEvent, AddressOf CheckingAccount_OverdraftEvent

   C#VB

   Pourquoi c'est important :

   • Le fait de ne pas se désabonner des événements peut entraîner des fuites de mémoire, car les objets à l'écoute des événements peuvent ne pas être correctement ramassés.

2. Utilisation de méthodes nommées :

   • Évitez d'utiliser des fonctions anonymes pour les gestionnaires d'événements, car il est alors difficile de se désinscrire des événements.
   // Good practice: using named methods for event handlers

   ' Good practice: using named methods for event handlers

   C#VB

Générique EventHandler : Passer une classe pour T

Tim Corey explique les meilleures pratiques pour transmettre des données par le biais d'événements, en particulier les avantages de l'utilisation d'une classe plutôt que de types de données simples comme les chaînes de caractères ou les décimales.

Pourquoi utiliser une classe pour les données d'événements

Tim commence par expliquer pourquoi l'utilisation de types de données simples pour les événements est moins courante et pourquoi il est généralement préférable de passer une classe :

1. Flexibilité et évolutivité :

   • L'utilisation d'une classe vous permet de transmettre plusieurs éléments de données connexes par le biais d'un événement. Si vous avez besoin d'ajouter des données plus tard, vous pouvez simplement étendre la classe sans modifier la signature de l'événement.

2. EventArgs Inheritance :

   • Auparavant, tout objet transmis par un événement devait hériter de EventArgs, mais ce n'est plus le cas aujourd'hui. Cependant, l'héritage d'EventArgs peut être bénéfique pour la cohérence et la clarté.

Création de la classe Overdraft EventArgs

Tim montre comment créer une classe EventArgs personnalisée pour l'événement de découvert.

1. Définir la classe :

   • Créez une nouvelle classe qui hérite de EventArgs et inclut des propriétés pour les données que vous souhaitez transmettre par le biais de l'événement.
   public class OverdraftEventArgs : EventArgs
   {
       public decimal AmountOverdrafted { get; private set; }
       public string MoreInfo { get; private set; }
   
       public OverdraftEventArgs(decimal amountOverdrafted, string moreInfo)
       {
           AmountOverdrafted = amountOverdrafted;
           MoreInfo = moreInfo;
       }
   }

   C#

2. Utilisation de la classe dans l'événement :

   • Mettez à jour la déclaration d'événement pour utiliser la classe EventArgs personnalisée.
   public event EventHandler<OverdraftEventArgs> OverdraftEvent;

   Public Event OverdraftEvent As EventHandler(Of OverdraftEventArgs)

   C#VB

3. Déclencher l'événement :

   • Passez une instance de la classe EventArgs personnalisée lorsque vous invoquez l'événement.
   OverdraftEvent?.Invoke(this, new OverdraftEventArgs(amountNeeded, "Additional info"));

   OverdraftEvent?.Invoke(Me, New OverdraftEventArgs(amountNeeded, "Additional info"))

   C#VB

Importance des propriétés en lecture seule

Tim souligne l'importance d'utiliser des propriétés en lecture seule dans la classe EventArgs afin d'éviter toute modification accidentelle des données de l'événement.

1. Éviter les modifications :

   • Si les propriétés de la classe EventArgs ont des paramètres publics, n'importe quel gestionnaire d'événement peut modifier les données, ce qui peut entraîner un comportement inattendu.
   • L'utilisation de paramètres privés et l'initialisation des propriétés par le biais du constructeur garantissent la cohérence des données relatives aux événements.

2. Exemple du problème :

   • Tim montre comment la modification des données d'un gestionnaire d'événements peut affecter d'autres gestionnaires si les propriétés ne sont pas en lecture seule.
   private void CheckingAccount_OverdraftEvent(object sender, OverdraftEventArgs e)
   {
       e.AmountOverdrafted = 1000; // This modification affects all handlers
   }

   C#

3. Solution :

   • Utilisez des paramètres privés et passez les données par le constructeur pour que les propriétés soient en lecture seule.
   public decimal AmountOverdrafted { get; private set; }
   public string MoreInfo { get; private set; }

   C#

Exception quand utiliser Public Set (59:29)

Tim Corey met en évidence une exception importante à la règle de l'utilisation de paramètres privés pour les propriétés de données d'événements. Cette exception se produit lorsque vous devez permettre aux auditeurs d'événements de modifier les données de l'événement, par exemple lorsqu'une transaction peut être annulée en fonction de certaines conditions.

Exemple : Annulation d'une transaction

Tim donne un exemple dans lequel un gestionnaire d'événements peut avoir besoin d'annuler une transaction. Pour ce faire, une propriété CancelTransaction est ajoutée à la classe EventArgs personnalisée.

1. Définir la propriété :

   • Ajoutez une propriété publique avec un getter et un setter à la classe EventArgs.
   public class OverdraftEventArgs : EventArgs
   {
       public decimal AmountOverdrafted { get; private set; }
       public string MoreInfo { get; private set; }
       public bool CancelTransaction { get; set; } = false;
   
       public OverdraftEventArgs(decimal amountOverdrafted, string moreInfo)
       {
           AmountOverdrafted = amountOverdrafted;
           MoreInfo = moreInfo;
       }
   }

   C#

2. Configuration de la propriété dans le gestionnaire d'événements :

   • Dans le tableau de bord, le gestionnaire d'événements peut définir cette propriété pour annuler la transaction.
   private void CheckingAccount_OverdraftEvent(object sender, OverdraftEventArgs e)
   {
       if (denyOverdraft.Checked)
       {
           e.CancelTransaction = true;
       }
       errorMessage.Text = $"You had an overdraft protection transfer of {e.AmountOverdrafted:C2}";
       errorMessage.Visible = true;
   }

   C#

3. Vérification de la propriété dans la méthode source :

   • Dans la méthode qui déclenche l'événement, vérifiez que la propriété CancelTransaction est définie sur true avant de poursuivre.
   if (args.CancelTransaction)
   {
       return false; // Transaction is canceled
   }

   C#

Rendre l'application plus interactive

Tim peaufine l'application pour la rendre plus interactive et plus conviviale.

1. Ajouter une case à cocher pour le contrôle des découverts :

   • Ajoutez au formulaire une case à cocher permettant à l'utilisateur d'activer ou de désactiver la protection contre les découverts.
   private void InitializeComponent()
   {
       this.denyOverdraft = new System.Windows.Forms.CheckBox();
       // Initialize other controls
       this.denyOverdraft.Text = "Stop Overdrafts";
       this.denyOverdraft.CheckedChanged += new System.EventHandler(this.denyOverdraft_CheckedChanged);
   }

   C#

2. Gestion de l'état des cases à cocher :

   • Dans le gestionnaire d'événements de la case à cocher, mettez à jour la logique pour prendre en compte l'état de la case à cocher lorsque vous décidez d'annuler une transaction.
   private void denyOverdraft_CheckedChanged(object sender, EventArgs e)
   {
       if (denyOverdraft.Checked)
       {
           // Logic to stop overdraft transactions
       }
   }

   C#

3. Mise à jour du gestionnaire d'événements :

   • Assurez-vous que le gestionnaire d'événements respecte l'état de la case à cocher pour autoriser ou refuser les découverts.
   private void CheckingAccount_OverdraftEvent(object sender, OverdraftEventArgs e)
   {
       if (denyOverdraft.Checked)
       {
           e.CancelTransaction = true;
       }
       errorMessage.Text = $"You had an overdraft protection transfer of {e.AmountOverdrafted:C2}";
       errorMessage.Visible = true;
   }

   C#

Résumé

Tim Corey conclut le didacticiel en résumant les points clés et les meilleures pratiques pour travailler avec des événements en C#.

1. Supprimer les écouteurs d'événements :

   • Pour éviter les fuites de mémoire, il faut toujours supprimer les auditeurs d'événements avant de détruire les objets.
   • Utilisez l'opérateur -= pour vous désinscrire des événements.
   customer.CheckingAccount.OverdraftEvent -= CheckingAccount_OverdraftEvent;

   RemoveHandler customer.CheckingAccount.OverdraftEvent, AddressOf CheckingAccount_OverdraftEvent

   C#VB

2. Utiliser EventArgs Héritage :

   • Bien que cela ne soit pas obligatoire, l'héritage d'EventArgs peut être bénéfique pour la cohérence et l'utilisation de fonctions intégrées telles que EventArgs.Empty.

3. Private Setters for Read-Only Properties :

   • Utilisez des paramètres privés pour éviter toute modification involontaire des données d'événement. N'autorisez les setters publics qu'en cas de nécessité, par exemple pour les transactions annulables.

4. Syntaxe du gestionnaire d'événements :

   • Utilisez le délégué EventHandler pour définir des événements, fournissant un modèle clair et cohérent pour transmettre les données d'événements.

5. Opérateur inconditionnel :

   • Utilisez l'opérateur null-conditional ( ?.Invoke()) pour invoquer des événements en toute sécurité sans risquer des exceptions de référence nulle.

Conclusion

Le tutoriel complet de Tim Corey sur les événements C# fournit des informations précieuses et des exemples pratiques pour créer, traiter et gérer efficacement les événements. En suivant ces bonnes pratiques, les développeurs peuvent créer des applications plus interactives et plus réactives.