C# Événement

Les événements C# (Event) sont des membres utilisés pour envoyer des notifications d'événement spécifiques aux abonnés. Les événements sont généralement utilisés pour implémenter le modèle observateur, qui permet à un objet de notifier d'autres objets des changements d'état sans avoir besoin de connaître les détails de ces objets.

ÉvénementFondamentalement, il s'agit d'une opération utilisateur, telle que des pressions de touches, des clics, des mouvements de souris, etc., ou de certaines informations d'invite, telles que des notifications générées par le système. Les applications doivent répondre aux événements lorsqu'ils se produisent. Par exemple, les interruptions.

En C#, le mécanisme d'événements est utilisé pour implémenter la communication entre les threads.

Points clés :

  • Déclarer un délégué: Définir le type de délégué que l'événement utilisera. Un délégué est une signature de fonction.
  • Déclarer un événement: UtilisezeventLe mot-clé déclare un événement.
  • Déclencher un événement: Appelez l'événement au moment approprié pour notifier tous les abonnés.
  • S'abonner aux événements et s'en désabonner: D'autres classes peuvent+=et-=utiliser des opérateurs pour s'abonner aux événements et s'en désabonner.

Utilisation des délégués via les événements

Les événements sont déclarés et déclenchés dans une classe, et sont associés à des gestionnaires d'événements via des délégués dans la même classe ou d'autres classes. La classe qui contient l'événement est utilisée pour publier l'événement. C'est ce qu'on appelle les classesÉditeur (publisher). Les autres classes qui acceptent cet événement sont appeléesAbonnéClasse. Utilisation des événementspublication-abonnement (éditeur-abonné)Modèle.

Éditeur (publisher)Est un objet qui contient les définitions d'événement et de délégué. La connexion entre l'événement et le délégué est également définie dans cet objet. Un objet de la classe éditeur appelle cet événement et notifie les autres objets.

AbonnéEst un objet qui accepte un événement et fournit un gestionnaire d'événements. Le délégué dans la classe éditeur appelle des méthodes (gestionnaires d'événements) dans la classe abonné.

Déclarer un événement (Event)

Pour déclarer un événement à l'intérieur d'une classe, vous devez d'abord déclarer le type délégué pour l'événement. Par exemple :

public delegate void BoilerLogHandler(string status);

Ensuite, déclarez l'événement lui-même, en utilisanteventmot-clé :

// 基于上面的委托定义事件
public event BoilerLogHandler BoilerEventLog;

Le code ci-dessus définit un délégué nomméBoilerLogHandleret un événement nomméBoilerEventLog, qui appelle le délégué lorsqu'il est déclenché.

L'exemple suivant montre comment utiliser les événements en C# :

Exemple

using System;

namespace EventDemo
{
    // Définir un type de délégué pour les gestionnaires d'événements
    public delegate void NotifyEventHandler(object sender, EventArgs e);

    // Classe éditeur
    public class ProcessBusinessLogic
    {
        // Déclarer l'événement
        public event NotifyEventHandler ProcessCompleted;

        // Méthode pour déclencher l'événement
        protected virtual void OnProcessCompleted(EventArgs e)
        {
            ProcessCompleted?.Invoke(this, e);
        }

        // Simuler le processus de logique métier et déclencher les événements
        public void StartProcess()
        {
            Console.WriteLine("Processus démarré !");

            // Vous pouvez ajouter la logique métier réelle ici

            // Logique métier terminée, déclencher l'événement
            OnProcessCompleted(EventArgs.Empty);
        }
    }

    // Classe d'abonné
    public class EventSubscriber
    {
        public void Subscribe(ProcessBusinessLogic process)
        {
            process.ProcessCompleted += Process_ProcessCompleted;
        }

        private void Process_ProcessCompleted(object sender, EventArgs e)
        {
            Console.WriteLine("Processus terminé !");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ProcessBusinessLogic process = new ProcessBusinessLogic();
            EventSubscriber subscriber = new EventSubscriber();

            // S'abonner à l'événement
            subscriber.Subscribe(process);

            // Processus de démarrage
            process.StartProcess();

            Console.ReadLine();
        }
    }
}

Description

1. Définir le type de délégué :

public delegate void NotifyEventHandler(object sender, EventArgs e);

Ceci est un type de délégué qui définit la signature du gestionnaire d'événements. On utilise généralementEventHandlerouEventHandler<TEventArgs>pour remplacer un délégué personnalisé.

2. Déclaration d'événements :

public event NotifyEventHandler ProcessCompleted;

Ceci est un événement qui utilise le type de délégué NotifyEventHandler.

3. Déclenchement des événements :

protected virtual void OnProcessCompleted(EventArgs e)
{
    ProcessCompleted?.Invoke(this, e);
}

Ceci est une méthode protégée utilisée pour déclencher l'événement. Utilisez?.Invokesyntaxe pour garantir que l'événement n'est invoqué que lorsqu'il y a des abonnés.

4. Abonnement et désabonnement aux événements:

process.ProcessCompleted += Process_ProcessCompleted;

Utilisation des abonnés+=opérateur pour s'abonner à un événement et définir un gestionnaire d'événementsProcess_ProcessCompleted。

Exemple

Exemple 1

using System;
namespace SimpleEvent
{
  using System;
  /***********Publisher class***********/
  public class EventTest
  {
    private int value;

    public delegate void NumManipulationHandler();


    public event NumManipulationHandler ChangeNum;
    protected virtual void OnNumChanged()
    {
      if ( ChangeNum != null )
      {
        ChangeNum(); /* L'événement est déclenché */
      }else {
        Console.WriteLine( "l'événement ne se déclenche pas" );
        Console.ReadKey(); /* appuyez sur Entrée pour continuer */
      }
    }


    public EventTest()
    {
      int n = 5;
      SetValue( n );
    }


    public void SetValue( int n )
    {
      if ( value != n )
      {
        value = n;
        OnNumChanged();
      }
    }
  }


  /***********Classe Subscriber***********/

  public class subscribEvent
  {
    public void printf()
    {
      Console.WriteLine( "l'événement se déclenche" );
      Console.ReadKey(); /* appuyez sur Entrée pour continuer */
    }
  }

  /***********déclencher emit***********/
  public class MainClass
  {
    public static void Main()
    {
      EventTest e = new EventTest(); /* Instancier l'objet, l'événement n'est pas déclenché la première fois */
      subscribEvent v = new subscribEvent(); /* Instancier l'objet */
      e.ChangeNum += new EventTest.NumManipulationHandler( v.printf ); /* Enregistrer */
      e.SetValue( 7 );
      e.SetValue( 11 );
    }
  }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

event not fire
event fire
event fire

Cet exemple fournit une application simple pour le dépannage d'un système de chaudière à eau chaude. Lorsque le technicien de maintenance inspecte la chaudière, la température et la pression de la chaudière, ainsi que les remarques du technicien de maintenance, sont automatiquement enregistrées dans le fichier journal.

Exemple 2

using System;
using System.IO;

namespace BoilerEventAppl
{
    // Classe Boiler
    class Boiler
    {
        public int Temp { get; private set; }
        public int Pressure { get; private set; }

        public Boiler(int temp, int pressure)
        {
            Temp = temp;
            Pressure = pressure;
        }
    }

    // Éditeur d'événements
    class DelegateBoilerEvent
    {
        public delegate void BoilerLogHandler(string status);

        // Définir un événement basé sur le délégué ci-dessus
        public event BoilerLogHandler BoilerEventLog;

        public void LogProcess()
        {
            string remarks = "O.K.";
            Boiler boiler = new Boiler(100, 12);
            int temp = boiler.Temp;
            int pressure = boiler.Pressure;

            if (temp > 150 || temp < 80 || pressure < 12 || pressure > 15)
            {
                remarks = "Maintenance requise";
            }

            OnBoilerEventLog($"Informations de journalisation :\nTempérature : {temp}\nPression : {pressure}\nMessage : {remarks}");
        }

        protected void OnBoilerEventLog(string message)
        {
            BoilerEventLog?.Invoke(message);
        }
    }

    // Cette classe conserve les termes pour l'écriture dans les fichiers journaux
    class BoilerInfoLogger : IDisposable
    {
        private readonly StreamWriter _streamWriter;

        public BoilerInfoLogger(string filename)
        {
            _streamWriter = new StreamWriter(new FileStream(filename, FileMode.Append, FileAccess.Write));
        }

        public void Logger(string info)
        {
            _streamWriter.WriteLine(info);
        }

        public void Dispose()
        {
            _streamWriter?.Close();
        }
    }

    // Abonné à l'événement
    public class RecordBoilerInfo
    {
        static void Logger(string info)
        {
            Console.WriteLine(info);
        }

        static void Main(string[] args)
        {
            using (BoilerInfoLogger fileLogger = new BoilerInfoLogger("e:\\boiler.txt"))
            {
                DelegateBoilerEvent boilerEvent = new DelegateBoilerEvent();
                boilerEvent.BoilerEventLog += Logger;
                boilerEvent.BoilerEventLog += fileLogger.Logger;
                boilerEvent.LogProcess();
            }

            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Logging info:

Temperature 100
Pressure 12

Message: O. K
autres extensions