Delegates e Eventos

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy. Lição 43 de 70.

Um delegate é um tipo que representa uma referência a um método. Pense nele como uma variável que contém um método em vez de dados. Isso permite passar métodos como argumentos, armazená-los em coleções e chamá-los dinamicamente.

Você declara um delegate especificando a assinatura do método ao qual ele pode fazer referência:

public delegate void Notify(string message);

public class Publisher
{
    public void SendAlert(string msg) => Console.WriteLine("Alert: " + msg);
}

// Uso
Notify notifier = new Publisher().SendAlert;
notifier("System started");  // Alerta: Sistema iniciado

Eventos baseiam-se em delegados para implementar o padrão publicar-assinar. Uma classe dispara um evento, e outras classes podem se inscrever para receber notificações. A palavra-chave event restringe como o delegado pode ser usado — os assinantes só podem adicionar ou remover manipuladores, não invocar o evento diretamente.

public class Button
{
    public event Action Clicked;
    
    public void Click()
    {
        Clicked?.Invoke();  // Notifica todos os assinantes
    }
}

// Assinando
Button btn = new Button();
btn.Clicked += () => Console.WriteLine("Button was clicked!");
btn.Click();  // Botão foi clicado!

O operador += inscreve um manipulador, enquanto -= cancela a inscrição. O padrão ?.Invoke() chama o evento com segurança somente se houver inscritos. Os eventos são fundamentais para aplicações de GUI, mecanismos de jogos e qualquer sistema em que os objetos precisem reagir a mudanças sem um acoplamento rígido.

Desafio

Fácil

Vamos criar um sistema de monitoramento de temperatura que usa delegados e eventos para notificar os assinantes sempre que a temperatura mudar. Este é um exemplo clássico do padrão publicador-assinante que os eventos permitem implementar com muita elegância.

Você organizará seu código em dois arquivos:

TemperatureMonitor.cs: crie uma classe TemperatureMonitor no namespace Monitoring que atuará como o publicador. Seu monitor deve:
- Ter um campo privado para armazenar a temperatura atual
- Declarar um evento usando Action<int> chamado TemperatureChanged, que será disparado sempre que a temperatura for atualizada
- Ter uma propriedade Temperature (int), cujo setter atualiza o campo privado e dispara o evento com o novo valor da temperatura
Lembre-se de usar o padrão ?.Invoke() para disparar o evento com segurança somente quando houver assinantes.
Program.cs: no seu arquivo principal, crie um TemperatureMonitor e inscreva dois manipuladores diferentes no evento TemperatureChanged:
- Um manipulador que imprime: Alert: Temperature is now {value} degrees
- Outro manipulador que imprime: Logged: {value}
Depois de inscrever os dois manipuladores, defina a temperatura duas vezes usando valores da entrada. Cada vez que você definir a temperatura, os dois manipuladores deverão responder.

Você receberá duas entradas:

Primeiro valor de temperatura (inteiro)
Segundo valor de temperatura (inteiro)

Por exemplo, se as entradas forem 25 e 30, a saída deverá ser:

Alert: Temperature is now 25 degrees
Logged: 25
Alert: Temperature is now 30 degrees
Logged: 30

Observe como definir a propriedade Temperature notifica automaticamente todos os assinantes — o monitor não precisa saber nada sobre quem está ouvindo. Essa é a beleza da abordagem orientada a eventos!

Experimente você mesmo

using System;
using Monitoring;

class Program
{
    public static void Main(string[] args)
    {
        // Ler entrada
        int temp1 = Convert.ToInt32(Console.ReadLine());
        int temp2 = Convert.ToInt32(Console.ReadLine());

        // TODO: Criar uma instância de TemperatureMonitor

        // TODO: Subscribe a handler that prints: "Alert: Temperature is now {value} degrees"

        // TODO: Inscrever outro handler que imprime: "Logged: {value}"

        // TODO: Definir a temperatura para temp1

        // TODO: Definir a temperatura para temp2
    }
}