Événement (Event) C#

C# orienté objet (OOP)

Les événements sont des notifications envoyées par un objet pour représenter l'occurrence d'une opération. Les événements .NET suivent le modèle de conception Observateur. La classe qui déclenche l'événement s'appelle

Publisher（发布者），la classe qui reçoit les notifications est appelée Subscriber（订阅者）。Un événement peut avoir plusieurs abonnés. Habituellement, le publisher déclenche un événement lors de l'exécution d'une opération. Les abonnés qui souhaitent être notifiés lors de l'exécution de l'opération doivent s'inscrire à l'événement et le traiter.

Dans C＃, les événements sont encapsulés dans des délégués. Ils dépendent des délégués. Les délégués définissent la signature de la méthode de gestionnaire d'événements pour la classe abonnée.

publishers d'événements et abonnés

utilisation de délégués pour les événements 发布者(publisher) classe. D'autres classes qui acceptent cet événement sont appelées classes abonnées(subscriber). Les événements sont déclarés et générés dans la classe et associés aux gestionnaires d'événements en utilisant des délégués de la même classe ou d'autres classes. La classe contenant des événements est utilisée pour publier des événements. Cela s'appelle publication-abonnement(publisher-subscriber) modèle.

发布者(publisher)- C'est un objet contenant des définitions d'événements et de délégués. La relation entre les événements et les délégués est également définie dans cet objet. Les objets de la classe publisher appellent cet événement et notifient d'autres objets.

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

Déclarer l'événement

Il est possible de déclarer un événement en deux étapes :

1. Déclarer un délégué

2. Déclarer une variable de délégué en utilisant la clé de mot 'event'

L'exemple suivant montre comment déclarer un événement dans la classe éditeur.

public delegate void Notify();　　//　Délégué
　　　　　　　　　　　　　　　　　　　　
public class ProcessBusinessLogic
{
　　　　public event Notify ProcessCompleted;　//　Événement
}

Dans l'exemple ci-dessus, nous avons déclaré un délégué Notify, puis nous avons déclaré l'événement ProcessCompleted du type de délégué Notify en utilisant la clé de mot 'event' dans la classe ProcessBusinessLogic. Par conséquent, la classe ProcessBusinessLogic est appelée publisher (éditeur). Le délégué Notify spécifie la signature du gestionnaire d'événement ProcessCompleted. Il spécifie que la méthode de gestionnaire d'événement de la classe subscriber (abonné) doit avoir un type de retour void et ne doit pas avoir de paramètres.

Maintenant, regardons comment déclencher l'événement ProcessCompleted. Regardons l'implémentation suivante.

public delegate void Notify();　　//　Délégué
　　　　　　　　　　　　　　　　　　　　
public class ProcessBusinessLogic
{
　　　　public event Notify ProcessCompleted;　//　Événement
　　　　public void StartProcess()
　　　　{
　　　　　　　　Console.WriteLine("Process Started!");
　　　　　　　　//　Certaines lignes de code ici...
　　　　　　　　OnProcessCompleted();
　　　　}
　　　　protected virtual void OnProcessCompleted()　//Méthode virtuelle protégée
　　　　{
　　　　　　　　//Si ProcessCompleted n'est pas null, appeler le délégué
　　　　　　　　ProcessCompleted?.Invoke();　
　　　　}
}

Au-dessus, la méthode StartProcess() appelle la méthode onProcessCompleted() à la fin, ce qui déclenche un événement. Habituellement, pour déclencher un événement, il faut utiliser la méthode protégée et virtuelle définie par le nom sur <EventName>. Les mots-clés protégés et virtuels permettent aux classes dérivées de redéfinir la logique de déclenchement de l'événement. Cependant, les classes dérivées devraient toujours appeler la méthode On<EventName> de la classe de base pour s'assurer que les délégués enregistrés reçoivent l'événement.

class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　ProcessBusinessLogic bl = new ProcessBusinessLogic();
　　　　　　　　bl.ProcessCompleted　+= bl_ProcessCompleted;　//　Enregistrer l'événement
　　　　　　　　bl.StartProcess();
　　　　}
　　　　//　Gestionnaire d'événement
　　　　public static void bl_ProcessCompleted()
　　　　{
　　　　　　　　Console.WriteLine("Process Complet!");
　　　　}
}

ci-dessus, la classe Program est ProcessCompleted Les abonnés à l'événement. Il utilise + L'opérateur = est utilisé pour enregistrer l'événement. N'oubliez pas que cela est similaire à la manière dont nous ajoutons des méthodes à la liste de rappel des délégués multicast. La méthode bl_processcompleted () traite cet événement parce qu'elle correspond à la signature du délégué Notify.

Délégué EventHandler intégré

.NET Framework contient des types de délégués intégrés pour les événements les plus courants, EventHandler et EventHandler <TEventArgs>. Souvent, tout événement doit inclure deux paramètres : l'origine de l'événement et les données de l'événement. Pour tous les événements qui ne contiennent pas de données d'événement, utilisez le délégué EventHandler. Pour les événements qui doivent envoyer des données au gestionnaire, utilisez le délégué EventHandler<TEventArgs>.

L'exemple affiché peut utiliser le délégué EventHandler sans avoir à déclarer un délégué personnalisé Notify, comme suit.

class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　ProcessBusinessLogic bl = new ProcessBusinessLogic();
　　　　　　　　bl.ProcessCompleted　+= bl_ProcessCompleted;　//　Enregistrement des événements
　　　　　　　　bl.StartProcess();
　　　　}
　　　　//　Traitement des événements
　　　　public static void bl_ProcessCompleted(object sender, EventArgs e)
　　　　{
　　　　　　　　Console.WriteLine("Process Complet!");
　　　　}
}
public class ProcessBusinessLogic
{
　　　　//　Déclarez l'événement en utilisant le délégué intégré
　　　　public event EventHandler ProcessCompleted;　
　　　　public void StartProcess()
　　　　{
　　　　　　　　Console.WriteLine("Process Started!");
　　　　　　　　//　Certaines lignes de code ici...
　　　　　　　　OnProcessCompleted(EventArgs.Empty);　//Pas de données d'événement
　　　　}
　　　　protected virtual void OnProcessCompleted(EventArgs e)
　　　　{
　　　　　　　　ProcessCompleted?.Invoke(this, e);
　　　　}
}

Transmettez les données d'événement

La plupart des événements envoient des données à l'abonné. La classe EventArgs est la classe de base de toutes les classes de données d'événement. .NET contient de nombreux types de données d'événement intégrés, tels que SerialDataReceivedEventArgs. Ils suivent le schéma de nommage où tous les types de données d'événement se terminent par EventArgs. Vous pouvez créer des classes personnalisées de données d'événement en dérivant EventArgs.

Transmettez les données à l'assistant de traitement en utilisant EventHandler <TEventArgs>, comme suit.

class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　ProcessBusinessLogic bl = new ProcessBusinessLogic();
　　　　　　　　bl.ProcessCompleted　+= bl_ProcessCompleted;　//　Enregistrement des événements
　　　　　　　　bl.StartProcess();
　　　　}
　　　　//　Traitement des événements
　　　　public static void bl_ProcessCompleted(object sender, bool IsSuccessful)
　　　　{
　　　　　　　　Console.WriteLine("Process "　+　(IsSuccessful ? "Completed Successfully" : "failed");
　　　　}
}
public class ProcessBusinessLogic
{
　　　　//　Déclarez l'événement en utilisant le délégué intégré
　　　　public event EventHandler<bool> ProcessCompleted;　
　　　　public void StartProcess()
　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("Process Started!");
　　　　　　　　　　　　//　Certaines lignes de code ici...
　　　　　　　　　　　　OnProcessCompleted(true);
　　　　　　　　}
　　　　　　　　catch(Exception ex)
　　　　　　　　{
　　　　　　　　　　　　OnProcessCompleted(false);
　　　　　　　　}
　　　　}
　　　　protected virtual void OnProcessCompleted(bool IsSuccessful)
　　　　{
　　　　　　　　ProcessCompleted?.Invoke(this, IsSuccessful);
　　　　}
}

Dans l'exemple précédent, nous transmettons une valeur booléenne unique au programme de traitement pour indiquer si le processus s'est terminé avec succès.

Si vous souhaitez transmettre plusieurs valeurs en tant que données d'événement, vous pouvez créer une classe dérivée de la classe de base EventArgs, comme suit.

class ProcessEventArgs : EventArgs
{
　　　　public bool IsSuccessful { get; set; }
　　　　public DateTime CompletionTime { get; set; }
}

L'exemple suivant montre comment transmettre la classe personnalisée ProcessEventArgs au programme de traitement.

class Program
{
　　　　public static void Main()
　　　　{
　　　　　　　　ProcessBusinessLogic bl = new ProcessBusinessLogic();
　　　　　　　　bl.ProcessCompleted　+= bl_ProcessCompleted;　//　Enregistrement des événements
　　　　　　　　bl.StartProcess();
　　　　}
　　　　//　Traitement des événements
　　　　public static void bl_ProcessCompleted(object sender, ProcessEventArgs e)
　　　　{
　　　　　　　　Console.WriteLine("Process "　+　(e.IsSuccessful ? "Completed Successfully" : "failed"));
　　　　　　　　Console.WriteLine("Completion Time: "　+　e.CompletionTime.ToLongDateString());
　　　　}
}
public class ProcessBusinessLogic
{
　　　　//　Déclarez l'événement en utilisant le délégué intégré
　　　　public event EventHandler<ProcessEventArgs> ProcessCompleted;　
　　　　public void StartProcess()
　　　　{
　　　　　　　　var data = new ProcessEventArgs();
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　　　Console.WriteLine("Process Started!");
　　　　　　　　　　　　//　Certaines lignes de code ici...
　　　　　　　　　　　　
　　　　　　　　　　　　data.IsSuccessful = true;
　　　　　　　　　　　　data.CompletionTime = DateTime.Now;
　　　　　　　　　　　　OnProcessCompleted(data);
　　　　　　　　}
　　　　　　　　catch(Exception ex)
　　　　　　　　{
　　　　　　　　　　　　data.IsSuccessful = false;
　　　　　　　　　　　　data.CompletionTime = DateTime.Now;
　　　　　　　　　　　　OnProcessCompleted(data);
　　　　　　　　}
　　　　}
　　　　protected virtual void OnProcessCompleted(ProcessEventArgs e)
　　　　{
　　　　　　　　ProcessCompleted?.Invoke(this, e);
　　　　}
}

Par conséquent, vous pouvez créer, déclencher, enregistrer et traiter des événements en C#.