Observação
Você pode conferir outras postagens no meu site pessoal: https://hbolajraf.net

O Observer Pattern é um padrão de design comportamental onde um objeto, conhecido como sujeito, mantém uma lista de seus dependentes, chamados observadores, e os notifica sobre quaisquer mudanças de estado, geralmente chamando um de seus métodos. Este padrão promove um acoplamento frouxo entre objetos, já que os observadores estão cientes apenas do sujeito e não uns dos outros. Em C#, esse padrão é comumente usado em programação orientada a eventos.

Implementação

Vamos entender o Observer Pattern através de um exemplo detalhado em C#.

Interface do Assunto

Primeiro, definimos uma interface para o assunto. Esta interface conterá métodos para registrar, cancelar registro e notificar observadores.

public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void UnregisterObserver(IObserver observer);
    void NotifyObservers();
}

Interface do observador

A seguir, definimos uma interface para o observador. Esta interface conterá um método que o sujeito chamará quando precisar notificar os observadores.

public interface IObserver
{
    void Update();
}

Assunto Concreto

Agora, vamos implementar uma classe de assunto concreta que implemente a interface ISubject.

public class ConcreteSubject : ISubject
{
    private List observers = new List();

    public void RegisterObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    public void UnregisterObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void NotifyObservers()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

Observador de Concreto

A seguir, vamos implementar uma classe de observador concreta que implemente a interface IObserver.

public class ConcreteObserver : IObserver
{
    public void Update()
    {
        Console.WriteLine("Observer notified of state change.");
    }
}

Exemplo de uso

Agora, vamos ver como podemos usar essas classes juntas.

class Program
{
    static void Main(string[] args)
    {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();

        subject.RegisterObserver(observer1);
        subject.RegisterObserver(observer2);

        subject.NotifyObservers();

        subject.UnregisterObserver(observer1);

        subject.NotifyObservers();
    }
}

Neste exemplo, ConcreteSubject é o sujeito e ConcreteObserver é o observador. Quando NotifyObservers() é chamado, ambos os observadores são notificados sobre a mudança de estado. Após cancelar o registro de um observador, apenas o observador restante será notificado.

Qual o proximo?

O Observer Pattern é uma maneira poderosa de implementar a comunicação entre objetos em C#. Promove acoplamento fraco e pode ser particularmente útil em arquiteturas orientadas a eventos. Ao compreender e implementar esse padrão, você pode escrever um código mais sustentável e escalonável.