Note
Vous pouvez consulter d'autres articles sur mon site personnel : https://hbolajraf.net

Le modèle d'observateur est un modèle de conception comportemental dans lequel un objet, appelé sujet, maintient une liste de ses dépendants, appelés observateurs, et les informe de tout changement d'état, généralement en appelant l'une de leurs méthodes. Ce modèle favorise un couplage lâche entre les objets, car les observateurs ne sont conscients que du sujet et non les uns des autres. En C#, ce modèle est couramment utilisé dans la programmation événementielle.

Mise en œuvre

Comprenons le modèle Observer à travers un exemple détaillé en C#.

Interface sujet

Tout d'abord, nous définissons une interface pour le sujet. Cette interface contiendra des méthodes pour enregistrer, désinscrire et notifier les observateurs.

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

Interface observateur

Ensuite, nous définissons une interface pour l'observateur. Cette interface contiendra une méthode que le sujet appellera lorsqu'il aura besoin de notifier les observateurs.

public interface IObserver
{
    void Update();
}

Sujet concret

Maintenant, implémentons une classe de sujet concrète qui implémente l'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();
        }
    }
}

Observateur du béton

Ensuite, implémentons une classe d'observateur concrète qui implémente l'interface IObserver.

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

Exemple d'utilisation

Voyons maintenant comment nous pouvons utiliser ces classes ensemble.

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();
    }
}

Dans cet exemple, ConcreteSubject est le sujet et ConcreteObserver est l'observateur. Lorsque NotifyObservers() est appelé, les deux observateurs sont informés du changement d'état. Après la désinscription d'un observateur, seul l'observateur restant est informé.

Et ensuite ?

Le modèle Observer est un moyen puissant d'implémenter la communication entre des objets en C#. Il favorise le couplage lâche et peut être particulièrement utile dans les architectures événementielles. En comprenant et en implémentant ce modèle, vous pouvez écrire un code plus maintenable et plus évolutif.