Notiz
Sie können andere Beiträge auf meiner persönlichen Website überprüfen: https://hbolajraf.net

Das Beobachtermuster ist ein Verhaltensentwurfsmuster, bei dem ein Objekt, das als Subjekt bezeichnet wird, eine Liste seiner abhängigen Objekte, sogenannte Beobachter, verwaltet und sie über alle Zustandsänderungen benachrichtigt, normalerweise durch Aufrufen einer ihrer Methoden. Dieses Muster fördert eine lockere Kopplung zwischen Objekten, da Beobachter nur das Subjekt und nicht einander wahrnehmen. In C# wird dieses Muster häufig in der ereignisgesteuerten Programmierung verwendet.

Implementierung

Lassen Sie uns das Observer-Muster anhand eines detaillierten Beispiels in C# verstehen.

Betreff-Schnittstelle

Zuerst definieren wir eine Schnittstelle für das Subjekt. Diese Schnittstelle enthält Methoden zum Registrieren, Aufheben der Registrierung und Benachrichtigen von Beobachtern.

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

Beobachterschnittstelle

Als nächstes definieren wir eine Schnittstelle für den Beobachter. Diese Schnittstelle enthält eine Methode, die das Subjekt aufruft, wenn es Beobachter benachrichtigen muss.

public interface IObserver
{
    void Update();
}

Konkretes Thema

Jetzt implementieren wir eine konkrete Subjektklasse, die die ISubject-Schnittstelle implementiert.

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

Konkreter Beobachter

Als nächstes implementieren wir eine konkrete Beobachterklasse, die die IObserver-Schnittstelle implementiert.

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

Beispielverwendung

Nun wollen wir sehen, wie wir diese Klassen zusammen verwenden können.

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

In diesem Beispiel ist ConcreteSubject das Subjekt und ConcreteObserver der Beobachter. Beim Aufruf von NotifyObservers() werden beide Beobachter über die Zustandsänderung benachrichtigt. Nach der Abmeldung eines Beobachters wird nur der verbleibende Beobachter benachrichtigt.

Was als nächstes?

Das Observer Pattern ist eine leistungsstarke Möglichkeit, die Kommunikation zwischen Objekten in C# zu implementieren. Es fördert die lose Kopplung und kann besonders in ereignisgesteuerten Architekturen nützlich sein. Durch das Verstehen und Implementieren dieses Musters können Sie besser wartbaren und skalierbaren Code schreiben.