Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C#

System.EventHandler<TEventArgs> et System.EventArgs

Choisis le délégué adapté à un événement avec ou sans données, puis retire les gestionnaires devenus inutiles.

Version : C# 12 and .NET 8; later runtimes may add compatible features

Syntaxe

// .NET 8 delegate signatures in namespace System (already provided by .NET):
public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);
public delegate void EventHandler(object? sender, EventArgs e);

// In a publisher class, with using System; and a custom MessageEventArgs : EventArgs:
public event EventHandler<MessageEventArgs>? MessagePublished;
public event EventHandler? Flushed;

// Inside an instance method of that publisher:
MessagePublished?.Invoke(this, new MessageEventArgs("Build complete"));
Flushed?.Invoke(this, EventArgs.Empty);

System.EventHandler<TEventArgs> est le type délégué utilisé pour déclarer un événement qui transporte des données. Un gestionnaire renvoie void et reçoit object? sender, généralement l’objet qui déclenche l’événement (cette valeur peut être null), puis TEventArgs e. System.EventArgs est une classe de base pour les données d’événement, pas un délégué. En C# 12 avec .NET 8, le délégué n’impose pas que TEventArgs hérite de EventArgs, mais c’est la convention .NET pour les classes de données personnalisées.

Dans un groupeur de notifications, déclare MessagePublished avec EventHandler<MessageEventArgs>. La classe MessageEventArgs : EventArgs expose la propriété Message en lecture seule : le gestionnaire lit e.Message sans conversion de type. Pour Flushed, utilise le type non générique distinct System.EventHandler : le second paramètre reste de type EventArgs, et l’éditeur transmet EventArgs.Empty, une instance partagée sans données supplémentaires, plutôt que null.

Le code extérieur s’abonne avec += et se désabonne avec -=, mais ne peut pas déclencher directement l’événement. La classe qui le déclare le déclenche avec ?.Invoke(this, e), qui n’effectue aucun appel en l’absence d’abonnés. Un appel ordinaire du délégué est synchrone. Si un gestionnaire lève une exception qu’il n’intercepte pas, elle se propage à l’appelant et les gestionnaires suivants ne sont pas appelés.

Utilise la même méthode pour t’abonner et te désabonner. Avec une lambda, conserve le délégué utilisé lors de l’abonnement. Désabonne-toi quand les notifications ne te sont plus utiles, surtout si l’éditeur vit plus longtemps que l’abonné : le délégué de l’éditeur peut maintenir l’objet abonné en vie.

Exemples

#nullable enable
using System;

var hub = new NotificationHub();
hub.MessagePublished += OnMessagePublished;
hub.Flushed += OnFlushed;

hub.Publish("Build complete");
hub.Flush();

hub.MessagePublished -= OnMessagePublished;
hub.Flushed -= OnFlushed;

hub.Publish("Not printed");
hub.Flush();

static void OnMessagePublished(object? sender, MessageEventArgs e)
    => Console.WriteLine(e.Message);

static void OnFlushed(object? sender, EventArgs e)
    => Console.WriteLine("Flushed");

sealed class MessageEventArgs : EventArgs
{
    public MessageEventArgs(string message) => Message = message;

    public string Message { get; }
}

sealed class NotificationHub
{
    public event EventHandler<MessageEventArgs>? MessagePublished;
    public event EventHandler? Flushed;

    public void Publish(string message)
        => MessagePublished?.Invoke(this, new MessageEventArgs(message));

    public void Flush()
        => Flushed?.Invoke(this, EventArgs.Empty);
}

Résultat

Build complete
Flushed

`NotificationHub` expose deux événements indépendants. Les premiers appels à `Publish` et à `Flush` affichent respectivement `Build complete` et `Flushed`. Une fois les deux gestionnaires retirés, les appels suivants n’affichent rien.

Leçons associées

  • C# · Leçon 23 · Intermédiaire · Version : 2
  • C# · Leçon 24 · Intermédiaire · Version : 2
  • C# · Leçon 25 · Intermédiaire · Version : 2

Sources