KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C#

System.EventHandler<TEventArgs> en System.EventArgs

Kies het juiste delegatetype voor een gebeurtenis met of zonder gegevens en meld overbodige handlers af.

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

Syntax

// .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> is het delegatetype waarmee je een gebeurtenis met gegevens declareert. Een handler retourneert void en krijgt object? sender, meestal het object dat de gebeurtenis activeert (de waarde kan null zijn), en TEventArgs e. System.EventArgs is een basisklasse voor gebeurtenisgegevens, geen delegate. In C# 12 op .NET 8 hoeft TEventArgs niet van EventArgs te erven, maar dat is wel de gebruikelijke .NET-conventie voor eigen klassen met gebeurtenisgegevens.

Declareer MessagePublished in een meldingshub met EventHandler<MessageEventArgs>. De klasse MessageEventArgs : EventArgs biedt de alleen-lezen-eigenschap Message, zodat een handler e.Message zonder cast kan lezen. Gebruik voor Flushed het afzonderlijke niet-generieke type System.EventHandler: de tweede parameter is nog steeds van het type EventArgs, en de uitgever geeft EventArgs.Empty, een gedeelde instantie zonder extra gegevens, door in plaats van null.

Externe code meldt een handler aan met += en af met -=, maar kan de gebeurtenis niet rechtstreeks activeren. De declarerende klasse activeert de gebeurtenis met ?.Invoke(this, e), dat de aanroep overslaat als er geen abonnees zijn. Een gewone delegate-aanroep verloopt synchroon. Als een handler een uitzondering opwerpt en die niet zelf afvangt, gaat die naar de aanroeper en worden latere handlers in de aanroeplijst overgeslagen.

Gebruik dezelfde methode om je aan en af te melden. Bewaar bij een lambda de delegate waarmee je je hebt aangemeld. Meld je af zodra je de meldingen niet meer nodig hebt, vooral als de uitgever langer leeft dan de abonnee: de delegate van de uitgever kan het abonneeobject in leven houden.

Voorbeelden

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

Resultaat

Build complete
Flushed

`NotificationHub` biedt twee onafhankelijke gebeurtenissen. De eerste aanroepen van `Publish` en `Flush` geven respectievelijk `Build complete` en `Flushed` weer. Nadat beide handlers zijn afgemeld, geven de volgende aanroepen niets weer.

Gerelateerde lessen

  • C# · Les 23 · Gemiddeld · Versie: 2
  • C# · Les 24 · Gemiddeld · Versie: 2
  • C# · Les 25 · Gemiddeld · Versie: 2

Bronnen