CKTIS / C#
System.EventHandler<TEventArgs> e System.EventArgs
Escolhe o delegado para um evento com ou sem dados e remove os processadores quando já não forem necessários.
Versão: C# 12 and .NET 8; later runtimes may add compatible features
Sintaxe
// .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> é o tipo de delegado usado para declarar um evento que transporta dados. Um processador do evento devolve void e recebe object? sender, normalmente o objeto que dispara o evento (pode ser null), e TEventArgs e. System.EventArgs é uma classe base para dados de eventos, não um delegado. Em C# 12 com .NET 8, o delegado não exige que TEventArgs herde de EventArgs, mas esta é a convenção do .NET para as classes de dados personalizadas.
Num agregador de notificações, declara MessagePublished com EventHandler<MessageEventArgs>. A classe MessageEventArgs : EventArgs expõe a propriedade Message só de leitura, pelo que um processador pode ler e.Message sem conversão de tipo. Para Flushed, usa o tipo não genérico distinto System.EventHandler: o segundo parâmetro continua a ser do tipo EventArgs, e o publicador passa EventArgs.Empty, uma instância partilhada sem dados adicionais, em vez de null.
O código externo subscreve com += e cancela a subscrição com -=, mas não pode disparar o evento diretamente. A classe que o declara dispara-o com ?.Invoke(this, e), que ignora a chamada caso não haja subscritores. Uma invocação normal do delegado é síncrona. Se um processador lançar uma exceção que não intercepte, esta propaga-se ao chamador e os processadores seguintes na lista não são executados.
Usa o mesmo método para subscrever e cancelar a subscrição. Se usares uma lambda, guarda o delegado usado para subscrever. Cancela a subscrição quando já não precisares das notificações, sobretudo se o publicador viver mais tempo do que o subscritor: o delegado do publicador pode manter o objeto subscritor vivo.
Exemplos
#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);
}Resultado
Build complete Flushed
`NotificationHub` expõe dois eventos independentes. As primeiras chamadas a `Publish` e `Flush` escrevem `Build complete` e `Flushed`, respetivamente. Depois de remover ambos os processadores, as chamadas seguintes não escrevem nada.
Lições relacionadas
- C# · Lição 23 · Intermédio · Versão: 2
- C# · Lição 24 · Intermédio · Versão: 2
- C# · Lição 25 · Intermédio · Versão: 2