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, na qual um objeto (o sujeito) notifica vários objetos dependentes (observadores) quando seu estado muda. Em C#, os eventos oferecem uma maneira integrada de implementar esse padrão com elegância.

O padrão envolve um publicador que gera 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: O preço agora é 150.50
// Registrado: 150.50

stock.PriceChanged -= logger.OnPriceChanged;  // Cancelar inscrição
stock.Price = 155.00m;
// Saída: Alerta: O preço agora é 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, o que facilita a extensão e a manutenção do sistema.

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 publicador — o objeto que outros objetos observarão. Seu sensor deve ter:
- Um campo privado para armazenar a temperatura atual
- Um evento chamado TemperatureChanged que usa Action<double> para notificar os inscritos sobre a nova temperatura
- Uma propriedade Temperature que dispara o evento sempre que a temperatura recebe um novo valor
Observers.cs: Crie duas classes observadoras no mesmo namespace que se inscreverão para receber as 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: Junte 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 com o valor da primeira entrada (ambos os observadores devem ser notificados)
Cancelar a inscrição de AlarmSystem no evento
Definir a temperatura do sensor com o valor da segunda entrada (somente a unidade de exibição deve ser notificada)

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

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

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

Experimente você mesmo

using System;
using Monitoring;

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

        // TODO: Crie uma instância de TemperatureSensor

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

        // TODO: Inscreva ambos os observadores no evento TemperatureChanged

        // TODO: Defina a temperatura do sensor como temp1 (ambos os observadores serão notificados)

        // TODO: Cancele a inscrição de AlarmSystem no evento

        // TODO: Defina a temperatura do sensor como temp2 (apenas DisplayUnit será notificado)
    }
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Programação Orientada a Objetos

3Arquitetura de Classes

Dados de Instância vs Estáticos Palavras-chave 'readonly' e 'const'Campos de Suporte Recapitulação - Gerenciador de Conta Bancária

6Encapsulamento

Modificadores de Acesso Propriedades para Encapsulamento Implementação de Ocultação de Dados Padrões de Imutabilidade Recapitulação - Registros de Estudantes

9Argumentos Variáveis

A Palavra-chave 'params'Parâmetros Opcionais Argumentos Nomeados Sobrecarga de Métodos

12Projeto: Sistema de Biblioteca

Estrutura do Projeto Modelos de Livro e Usuário Lógica do Sistema de Empréstimos LINQ para Buscas Interface de Console / Interface de Admin Testes de Unidade (NUnit/xUnit)

Pratique por conta própria: Compilador de C# online