Comprendre l'événement C#

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.

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 EventHandler<string> RaiseTransactionApprovedEvent;

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 de l'événement (dans ce cas, une chaîne de caractères).

   private void OnTransactionApproved(string transactionName)
   {
      RaiseTransactionApprovedEvent?.Invoke(this, transactionName);
   }

   private void OnTransactionApproved(string transactionName)
   {
      RaiseTransactionApprovedEvent?.Invoke(this, transactionName);
   }

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
   }

   account.RaiseTransactionApprovedEvent += Account_RaiseTransactionApprovedEvent;
   
   private void Account_RaiseTransactionApprovedEvent(object sender, string e)
   {
      // Code to handle the event
   }

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);
   }

   public void AddDeposit(decimal amount, string depositName)
   {
      // Code to add deposit
      RaiseTransactionApprovedEvent?.Invoke(this, depositName);
   }

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
   }

   public MainForm()
   {
      InitializeComponent();
      account.RaiseTransactionApprovedEvent += Account_RaiseTransactionApprovedEvent;
   }
   
   private void Account_RaiseTransactionApprovedEvent(object sender, string e)
   {
      // Update the UI with the new transaction
   }

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.

É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;

   customer.CheckingAccount.TransactionApprovedEvent += CheckingAccount_TransactionApprovedEvent;

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");
   }

   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");
   }

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);
   }

   private void OnTransactionApproved(string transactionName)
   {
      RaiseTransactionApprovedEvent?.Invoke(this, transactionName);
   }

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");
   }

   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");
   }

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
   }

   private void CheckingAccount_TransactionApprovedEvent(object sender, string e)
   {
      // Breakpoint here
   }

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.

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;

   customer.CheckingAccount.OverdraftEvent += CheckingAccount_OverdraftEvent;

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;
   }

   private void CheckingAccount_OverdraftEvent(object sender, decimal e)
   {
      errorMessage.Text = $"You had an overdraft protection transfer of {e:C2}";
      errorMessage.Visible = true;
   }

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

É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" />

   <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;

   customer.CheckingAccount.OverdraftEvent += SecondaryForm_OverdraftEvent;

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;
   }

   private void SecondaryForm_OverdraftEvent(object sender, decimal e)
   {
      errorMessage.Visible = true;
   }

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.

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;

   customer.CheckingAccount.OverdraftEvent -= CheckingAccount_OverdraftEvent;

   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

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.

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
   }

   private void CheckingAccount_OverdraftEvent(object sender, OverdraftEventArgs e)
   {
      e.AmountOverdrafted = 1000; // This modification affects all handlers
   }

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; }

   public decimal AmountOverdrafted { get; private set; }
   public string MoreInfo { get; private set; }

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.

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);
   }

   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);
   }

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
      }
   }

   private void denyOverdraft_CheckedChanged(object sender, EventArgs e)
   {
      if (denyOverdraft.Checked)
      {
          // Logic to stop overdraft transactions
      }
   }

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;
   }

   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;
   }