Comprensión de eventos en C#

Introducción a los eventos

En C# y en los lenguajes de programación, los eventos desempeñan un papel fundamental en la programación basada en eventos, ya que permiten a las aplicaciones responder a acciones como interacciones del usuario o cambios en el sistema. En comparación con otros lenguajes de programación, C# ofrece un enfoque estructurado para el manejo de eventos, lo que lo hace ideal para aplicaciones rápidas y pequeñas. Los eventos en C# se desencadenan mediante acciones específicas, y estas acciones invocan a los manejadores de eventos correspondientes para realizar las tareas deseadas.

Tim comienza explicando que la mayoría de los desarrolladores están familiarizados con los eventos en C#, pero pueden no saber cómo crear eventos personalizados. El objetivo del vídeo es presentar los eventos, explicar cómo crear eventos personalizados, hablar de sus características y describir las mejores prácticas.

Paseo por la aplicación demo

Tim utiliza una sencilla aplicación bancaria construida con Windows Forms (WinForms) para demostrar los eventos. La aplicación simula las operaciones bancarias básicas de un cliente, incluida la consulta de saldos y el registro de transacciones.

1. Resumen de la aplicación:

   • La aplicación tiene dos formularios: uno para mostrar saldos de cuentas y transacciones, y otro para registrar nuevas transacciones.
   • Incluye botones para simular compras con tarjeta de crédito y gestionar descubiertos transfiriendo fondos de la cuenta de ahorros a la cuenta corriente.

2. Formato principal:

   • Muestra el nombre del cliente y los saldos de sus cuentas corrientes y de ahorro.
   • Muestra listas de transacciones para ambas cuentas.
   • Contiene un botón para abrir el formulario de registro de transacciones.

3. Formulario de transacción:

   • Permite al usuario introducir los importes de las transacciones.
   • Simula la realización de compras y gestiona los descubiertos transfiriendo fondos de la cuenta de ahorros a la cuenta corriente.

Código de la aplicación de demostración

Tim explica el código backend de la aplicación bancaria de demostración:

1. Clase de cliente:

   • Representa a un cliente con propiedades para el nombre del cliente y dos cuentas (corriente y ahorros).
   • La clase Cliente es sencilla, pero sirve como un buen punto de partida para entender cómo gestionar varias cuentas.

2. Clase de cuenta:

   • Gestiona los detalles de una cuenta bancaria, incluidos el nombre de la cuenta, el saldo y la lista de transacciones.
   • La propiedad Balance es de tipo decimal para cálculos monetarios precisos.
   • La propiedad Transactions es una lista de sólo lectura para evitar modificaciones externas.

3. Gestión de depósitos y pagos:

   • Método AddDeposit: Añade un depósito a la cuenta, actualiza el saldo y registra la transacción.
   • Método MakePayment: Gestiona las retiradas de fondos, incluyendo la comprobación de fondos suficientes y la gestión de la protección contra sobregiros mediante la transferencia de fondos desde una cuenta de respaldo si es necesario.

4. Protección contra sobregiros:

   • La aplicación incluye lógica para gestionar descubiertos. Si el saldo de la cuenta corriente es insuficiente para una transacción, la aplicación consulta la cuenta de ahorros para cubrir el déficit. Si el saldo combinado es suficiente, transfiere la cantidad requerida a la cuenta corriente y completa la transacción.

Para ver ejemplos de código, puede consultar directamente el vídeo de Tim Corey en el que explica el código desde el minuto 3:18 hasta el 18:27.

Evento: Clic de botón

En esta sección, Tim Corey se sumergió en el funcionamiento de los eventos de clic de botón en Windows Forms, explicando cómo se conectan estos eventos y cómo funcionan.

Creación e invocación de eventos personalizados

Tim explica cómo crear eventos personalizados en C#, empezando por la clase Account, donde se activarán los eventos.

1. Definición de un evento:

   • Un evento se define mediante la palabra clave event. Su aspecto es similar al de una variable pública, pero es específica para eventos.

   public event EventHandler<string> RaiseTransactionApprovedEvent;

   public event EventHandler<string> RaiseTransactionApprovedEvent;

2. Desencadenante del evento:

   • Los eventos se activan mediante el método Invoke, normalmente dentro de la clase que define el evento. El método Invoke toma dos parámetros: el remitente (usualmente this) y los datos del evento (en este caso, una cadena).

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

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

3. Cableado y manejo de eventos:

   • Suscríbase al evento utilizando el operador += y defina un método para gestionar el evento cuando se produzca.

   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
   }

Uso de eventos para actualizar la interfaz de usuario

Tim explica cómo utilizar eventos para actualizar automáticamente la interfaz de usuario del navegador cuando se producen determinadas acciones, como la aprobación de una transacción.

1. Eventos de recaudación:

   • Activar el evento personalizado después de que se apruebe una transacción.

   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. Suscripción a eventos en la interfaz de usuario:

   • Suscríbase al evento en el formulario principal para actualizar la lista de transacciones cada vez que se apruebe una nueva transacción.

   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() Explicado

Tim Corey explica el uso de la sintaxis ?.Invoke() al lanzar eventos en C#. Este enfoque moderno simplifica el código y garantiza la seguridad de los hilos.

Escuchar y escribir código para el evento

Tim explica cómo escuchar eventos personalizados en una aplicación Windows Forms y actualizar la interfaz de usuario en consecuencia.

1. Suscripción a eventos:

   • Suscríbase al evento personalizado utilizando el operador +=.

   customer.CheckingAccount.TransactionApprovedEvent += CheckingAccount_TransactionApprovedEvent;

   customer.CheckingAccount.TransactionApprovedEvent += CheckingAccount_TransactionApprovedEvent;

2. Método de gestión de eventos:

   • Definir un método para manejar el evento. Este método actualiza la interfaz de usuario en función de los datos del evento.

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

Creación del evento personalizado: Evento en acción y recapitulación

Tim muestra en acción todo el proceso de creación, activación y gestión de eventos personalizados.

1. Desencadenante del evento:

   • Lance el evento después de que se apruebe una transacción o cuando cambie el saldo.

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

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

2. Manejo de múltiples eventos:

   • Asegúrese de que la aplicación escucha múltiples eventos, como transacciones y cambios de saldo, para mantener la interfaz de usuario actualizada en tiempo real.

   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. Ejecución de la aplicación:

   • Tim ejecuta la aplicación para demostrar cómo la interfaz de usuario se actualiza automáticamente en función de los eventos desencadenados por las transacciones.

Información sobre argumentos de eventos: Depuración

Tim muestra cómo depurar eventos e inspeccionar la información que se envía con ellos.

1. Cómo establecer un punto de interrupción:

   • Establezca un punto de interrupción en el método del manejador de eventos para inspeccionar los datos del evento.

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

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

2. Depuración :

   • Ejecute la aplicación y realice una transacción para activar el evento. Inspeccionar los argumentos de eventos en el depurador.
   • El parámetro sender proporciona la instancia que ha generado el evento, y el parámetro e contiene los datos del evento.

Creación de otro evento personalizado (evento de sobregiro)

Tim Corey amplía la demostración creando otro evento personalizado para gestionar situaciones de descubierto. Este evento se activará cuando se produzca un descubierto y notificará al usuario el importe del mismo.

Suscripción al evento de sobregiro en el lado del salpicadero

1. Cableado del evento :

   • Suscríbase al evento de sobregiro en el formulario del panel de control.

   customer.CheckingAccount.OverdraftEvent += CheckingAccount_OverdraftEvent;

   customer.CheckingAccount.OverdraftEvent += CheckingAccount_OverdraftEvent;

2. Gestión del evento:

   • Defina un controlador de eventos para mostrar un mensaje cuando se produzca un descubierto.

   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. Desencadenamiento y visualización del evento:

   • Cuando se produce un descubierto, el evento se activa y actualiza la interfaz de usuario para notificárselo al usuario.

   You had an overdraft protection transfer of $20.44

Escuchar el evento en varios lugares

Tim explica cómo escuchar el mismo evento en varios idiomas y formas, demostrando la versatilidad de los eventos.

1. Añadir una etiqueta a otro formulario:

   • Añadir una etiqueta a un formulario secundario para mostrar mensajes de descubierto.

   <asp:Label ID="errorMessage" runat="server" Visible="false" />

   <asp:Label ID="errorMessage" runat="server" Visible="false" />

   HTML

2. Suscripción al evento:

   • Suscríbase al evento de sobregiro en el formulario secundario.

   customer.CheckingAccount.OverdraftEvent += SecondaryForm_OverdraftEvent;

   customer.CheckingAccount.OverdraftEvent += SecondaryForm_OverdraftEvent;

3. Gestión del evento:

   • Defina un controlador de eventos para mostrar el mensaje de descubierto en el formulario secundario.

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

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

4. Manejo simultáneo de eventos:

   • Tim demuestra que el evento puede gestionarse de varias formas simultáneamente, lo que garantiza que todas las partes relevantes de la aplicación respondan al evento adecuadamente.

   Both the main form and the secondary form display the overdraft message when the event is triggered.

Quitar de la memoria los receptores de eventos

Tim destaca la importancia de limpiar los escuchadores de eventos para evitar fugas de memoria y garantizar un rendimiento adecuado de la aplicación.

1. Desuscripción de eventos:

   • Es crucial darse de baja de los eventos antes de destruir una instancia de clase o cerrar un formulario.

   customer.CheckingAccount.OverdraftEvent -= CheckingAccount_OverdraftEvent;

   customer.CheckingAccount.OverdraftEvent -= CheckingAccount_OverdraftEvent;

   Por qué es importante:

   • Si no se cancela la suscripción a eventos, pueden producirse fugas de memoria, ya que es posible que los objetos que escuchan los eventos no se recojan correctamente.

2. Uso de métodos con nombre:

   • Evite el uso de funciones anónimas para los manejadores de eventos, ya que dificulta la cancelación de la suscripción a los eventos.

   // Good practice: using named methods for event handlers

   // Good practice: using named methods for event handlers

Generic EventHandler: Pasando una Clase por T

Tim Corey explica las mejores prácticas para pasar datos a través de eventos, en particular las ventajas de utilizar una clase en lugar de tipos de datos simples como string o decimal.

Importancia de las propiedades de sólo lectura

Tim hace hincapié en la importancia de utilizar propiedades de sólo lectura en la clase EventArgs para evitar la modificación accidental de los datos de eventos.

1. Evitar modificaciones:

   • Si las propiedades de la clase EventArgs tienen definidores públicos, cualquier controlador de eventos puede modificar los datos, lo que puede provocar un comportamiento inesperado.
   • El uso de setters privados y la inicialización de propiedades a través del constructor garantizan la coherencia de los datos de eventos.

2. Ejemplo del problema:

   • Tim demuestra cómo la modificación de los datos de un evento en un manejador de eventos puede afectar a otros manejadores si las propiedades no son de sólo lectura.

   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. Solución:

   • Utilice setters privados y pase datos a través del constructor para que las propiedades sean de sólo lectura.

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

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

Excepción de cuándo usar Public Set (59:29)

Tim Corey destaca una importante excepción a la regla de utilizar definidores privados para las propiedades de datos de eventos. Esta excepción se da cuando es necesario permitir que los oyentes de eventos modifiquen los datos del evento, como en los casos en los que una transacción podría cancelarse en función de ciertas condiciones.

Hacer la aplicación más interactiva

Tim perfecciona la aplicación para hacerla más interactiva y fácil de usar.

1. Añadir una casilla de verificación para el control de sobregiros:

   • Añada una casilla de verificación al formulario que permita al usuario activar o desactivar la protección contra sobregiros.

   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. Manejo del estado de las casillas de verificación:

   • En el controlador de eventos de la casilla de verificación, actualice la lógica para tener en cuenta el estado de la casilla de verificación cuando se decida cancelar una transacción.

   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. Actualización del controlador de eventos:

   • Asegúrese de que el controlador de eventos respeta el estado de la casilla de verificación para permitir o denegar los descubiertos.

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