Nota
Puedes consultar otras publicaciones en mi sitio web personal: https://hbolajraf.net

El patrón de observador es un patrón de diseño de comportamiento en el que un objeto, conocido como sujeto, mantiene una lista de sus dependientes, llamados observadores, y les notifica cualquier cambio de estado, generalmente llamando a uno de sus métodos. Este patrón promueve un acoplamiento débil entre objetos, ya que los observadores sólo son conscientes del sujeto y no de los demás. En C#, este patrón se usa comúnmente en la programación basada en eventos.

Implementación

Entendamos el patrón Observer a través de un ejemplo detallado en C#.

Interfaz de sujeto

Primero, definimos una interfaz para el tema. Esta interfaz contendrá métodos para registrar, cancelar el registro y notificar a los observadores.

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

Interfaz de observador

A continuación, definimos una interfaz para el observador. Esta interfaz contendrá un método que el sujeto llamará cuando necesite notificar a los observadores.

public interface IObserver
{
    void Update();
}

Asunto Concreto

Ahora, implementemos una clase de sujeto concreta que implemente la interfaz 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 concreto

A continuación, implementemos una clase de observador concreta que implemente la interfaz IObserver.

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

Uso de ejemplo

Ahora, veamos cómo podemos usar estas clases 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();
    }
}

En este ejemplo, ConcreteSubject es el sujeto y ConcreteObserver es el observador. Cuando se llama a NotifyObservers(), se notifica a ambos observadores del cambio de estado. Después de cancelar el registro de un observador, solo se notifica al observador restante.

¿Qué sigue?

El patrón Observer es una forma poderosa de implementar la comunicación entre objetos en C#. Promueve un acoplamiento flexible y puede resultar particularmente útil en arquitecturas basadas en eventos. Al comprender e implementar este patrón, podrá escribir código más fácil de mantener y escalable.