Padrão Observer (Eventos)

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

O padrão Observer estabelece uma relação de um-para-muitos onde um objeto (o sujeito) notifica múltiplos objetos dependentes (observadores) quando seu estado muda. No C#, eventos fornecem uma maneira nativa de implementar este padrão de forma elegante.

O padrão envolve um publicador que dispara eventos e assinantes que respondem a eles. Aqui está um exemplo prático de um monitor de preços de ações:

public class Stock
{
    private decimal _price;
    
    public event Action<decimal> PriceChanged;
    
    public decimal Price
    {
        get => _price;
        set
        {
            _price = value;
            PriceChanged?.Invoke(_price);  // Notifica todos os observadores
        }
    }
}

public class PriceAlert
{
    public void OnPriceChanged(decimal newPrice)
    {
        Console.WriteLine($"Alert: Price is now {newPrice}");
    }
}

public class PriceLogger
{
    public void OnPriceChanged(decimal newPrice)
    {
        Console.WriteLine($"Logged: {newPrice}");
    }
}

Os assinantes vinculam seus métodos ao evento usando += e podem desvinculá-los com -=:

var stock = new Stock();
var alert = new PriceAlert();
var logger = new PriceLogger();

stock.PriceChanged += alert.OnPriceChanged;
stock.PriceChanged += logger.OnPriceChanged;

stock.Price = 150.50m;
// Saída:
// Alerta: Price is now 150.50
// Registrado: 150.50

stock.PriceChanged -= logger.OnPriceChanged;  // Cancelar inscrição
stock.Price = 155.00m;
// Saída: Alerta: Price is now 155.00

O padrão Observer promove o baixo acoplamento - a classe Stock não precisa saber nada sobre seus observadores. Novos observadores podem se inscrever sem modificar o publicador, tornando o sistema fácil de estender e manter.

Desafio

Fácil

Vamos criar um sistema de monitoramento de temperatura usando o padrão Observer com eventos. Você criará um sensor que notifica vários observadores sempre que a temperatura muda — perfeito para cenários como sistemas de controle climático, nos quais diferentes componentes precisam reagir às atualizações de temperatura.

Você organizará seu código em três arquivos:

TemperatureSensor.cs: crie uma classe TemperatureSensor no namespace Monitoring. Este é o seu publicador — o assunto que será observado por outros objetos. Seu sensor deve ter:
- um campo privado para armazenar a temperatura atual
- um evento chamado TemperatureChanged que usa Action<double> para notificar os assinantes sobre a nova temperatura
- uma propriedade Temperature que dispara o evento sempre que a temperatura é definida com um novo valor
Observers.cs: crie duas classes observadoras no mesmo namespace que se inscreverão nas mudanças de temperatura:
- DisplayUnit — tem um método OnTemperatureChanged(double temp) que imprime Display: {temp}C
- AlarmSystem — tem um método OnTemperatureChanged(double temp) que imprime Alarm Check: {temp}C
Program.cs: reúna tudo criando um sensor e os dois observadores. Inscreva ambos os observadores no evento do sensor e, em seguida, atualize a temperatura. Depois disso, cancele a inscrição do sistema de alarme e atualize a temperatura novamente para mostrar que somente a unidade de exibição recebe a notificação.

Você receberá duas entradas:

Primeira leitura de temperatura (por exemplo, 22.5)
Segunda leitura de temperatura (por exemplo, 28.0)

Seu programa deve:

criar o sensor e os dois observadores
inscrever ambos os observadores no evento TemperatureChanged
definir a temperatura do sensor como o primeiro valor de entrada (ambos os observadores devem ser notificados)
cancelar a inscrição do AlarmSystem no evento
definir a temperatura do sensor como o segundo valor de entrada (somente a unidade de exibição deve ser notificada)

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

Display: 22.5C
Alarm Check: 22.5C
Display: 28C

Isso demonstra o poder central do padrão Observer — o sensor não sabe nem se importa com quem está escutando. Os observadores podem se inscrever e cancelar a inscrição dinamicamente, e o publicador simplesmente notifica quem estiver escutando no momento!

Experimente você mesmo

using System;
using Monitoring;

class Program
{
    public static void Main(string[] args)
    {
        // Ler as temperaturas de entrada
        double temp1 = Convert.ToDouble(Console.ReadLine());
        double temp2 = Convert.ToDouble(Console.ReadLine());

        // TODO: Criar uma instância de TemperatureSensor

        // TODO: Criar instâncias de DisplayUnit e AlarmSystem

        // TODO: Inscrever ambos os observadores no evento TemperatureChanged

        // TODO: Definir a temperatura do sensor para temp1 (ambos os observadores notificados)

        // TODO: Cancelar a inscrição do AlarmSystem no evento

        // TODO: Definir a temperatura do sensor para temp2 (apenas o display notificado)
    }
}