Eventos: publicação/assinatura, palavra-chave event
Publique e assine com eventos: declare um evento, adicione e remova manipuladores, passe dados por meio de EventArgs e dispare-o seguindo o padrão OnX.
Eventos: publicação/assinatura, palavra-chave event é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.
Visão geral dos eventos
Objetivo: publicar e assinar usando eventos.
- Declare um evento no publicador
- Assine com += e cancele a assinatura com -=
- Dispare o evento com segurança no publicador
- Passe dados usando EventArgs
Uso básico de eventos
Exponha um evento e permita que os ouvintes se conectem e desconectem. Somente o publicador o invoca.
using System;
public class Button
{
public event EventHandler Click;
public void SimulateClick()
{
// Safe raise: copy then invoke if not null (C# 6-safe)
EventHandler h = Click;
if (h != null) h(this, EventArgs.Empty);
}
}
public class Program
{
static void OnClick(object sender, EventArgs e)
{
Console.WriteLine("Clicked!");
}
public static void Main(string[] args)
{
Button b = new Button();
b.Click += OnClick; // subscribe
b.SimulateClick(); // prints "Clicked!"
b.Click -= OnClick; // unsubscribe
b.SimulateClick(); // no output
}
}
Evento com dados
Use EventArgs (ou EventHandler<TEventArgs>) para passar dados úteis aos assinantes.
using System;
// Data for the event
public sealed class PriceChangedEventArgs : EventArgs
{
public decimal OldPrice { get; private set; }
public decimal NewPrice { get; private set; }
public PriceChangedEventArgs(decimal oldP, decimal newP)
{
OldPrice = oldP; NewPrice = newP;
}
}
public sealed class Product
{
private decimal _price;
public event EventHandler<PriceChangedEventArgs> PriceChanged;
public decimal Price
{
get { return _price; }
set
{
if (value != _price)
{
decimal old = _price;
_price = value;
EventHandler<PriceChangedEventArgs> h = PriceChanged;
if (h != null) h(this, new PriceChangedEventArgs(old, _price));
}
}
}
}
public class Program
{
public static void Main(string[] args)
{
Product p = new Product();
p.PriceChanged += delegate(object s, PriceChangedEventArgs e)
{
Console.WriteLine("Price: " + e.OldPrice + " -> " + e.NewPrice);
};
p.Price = 10m;
p.Price = 12m;
}
}
Multicast e expressões lambda
Os eventos são de difusão múltipla: vários manipuladores são executados na ordem de assinatura. Use manipuladores nomeados ou anônimos.
using System;
public class Alarm
{
public event EventHandler Ring;
public void Trigger()
{
EventHandler h = Ring;
if (h != null) h(this, EventArgs.Empty);
}
}
public class Program
{
static void HandlerA(object s, EventArgs e) { Console.WriteLine("A"); }
static void HandlerB(object s, EventArgs e) { Console.WriteLine("B"); }
public static void Main(string[] args)
{
Alarm a = new Alarm();
a.Ring += HandlerA; // named
a.Ring += delegate(object s, EventArgs e) { Console.WriteLine("lambda"); }; // anon
a.Ring += HandlerB;
a.Trigger(); // prints A, lambda, B (multicast order)
}
}
Padrão de disparo OnX
Use um método OnX protegido para disparar eventos. Copie o delegado para uma variável local e verifique se ele é nulo antes de invocá-lo.
using System;
public class Ticker
{
public event EventHandler Tick;
protected virtual void OnTick()
{
EventHandler h = Tick; // copy to local
if (h != null) h(this, EventArgs.Empty);
}
public void RunOnce()
{
// do work...
OnTick(); // raise via protected method
}
}
public class Program
{
static void Show(object s, EventArgs e) { Console.WriteLine("Tick!"); }
public static void Main(string[] args)
{
Ticker t = new Ticker();
t.Tick += Show;
t.RunOnce();
}
}
Dicas e armadilhas dos eventos
Dicas:
- Sempre cancele a assinatura ( -= ) quando um assinante não for mais necessário.
- Mantenha os manipuladores curtos; trabalhos longos devem ser colocados em uma fila.
- Use EventArgs (ou uma subclasse) para passar dados.
- Somente o publicador deve disparar o evento.
Função da palavra-chave event
Recapitulação
Recapitulação: declare um evento, permita que os ouvintes se conectem e desconectem, passe dados com EventArgs e dispare o evento por meio de um método OnX protegido.
Perguntas Frequentes
A aula “Eventos: publicação/assinatura, palavra-chave event” é grátis?
Sim — o texto completo de “Eventos: publicação/assinatura, palavra-chave event” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.
O que vou aprender em “Eventos: publicação/assinatura, palavra-chave event”?
Publique e assine com eventos: declare um evento, adicione e remova manipuladores, passe dados por meio de EventArgs e dispare-o seguindo o padrão OnX. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “Eventos: publicação/assinatura, palavra-chave event”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- delegate, Action/Func, fechamentos
- Eventos: publicação/assinatura, palavra-chave event
- Padrões de eventos e armadilhas (vazamentos de memória)