Explaining the Observer Design Pattern: A Comprehensive Guide

SF Games
January 07, 2023

Explaining the Observer Design Pattern: A Comprehensive Guide

The Observer design pattern is a software design pattern that defines a one-to-many relationship between objects, where one object (the subject) maintains a list of its dependents (the observers) and automatically notifies them of any state changes. This pattern is useful when you have an object that needs to notify other objects when its state changes, but you don't want the objects to have explicit references to each other. Instead, the objects are loosely coupled, and can be easily added or removed from the notification list.

One way to implement the Observer pattern is to have the subject maintain a list of observers and provide methods for adding or removing observers from the list. The subject should also have a method for notifying its observers when its state changes. The observers should have a method for receiving notification from the subject and updating their state accordingly.

Here is an example of the Observer pattern in action using C#:


public interface IObserver
{
    void Update(ISubject subject);
}

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public class Subject : ISubject
{
    private List<IObserver> _observers = new List<IObserver>();
    private int _state;

    public int State
    {
        get { return _state; }
        set
        {
            _state = value;
            Notify();
        }
    }

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in _observers)
        {
            observer.Update(this);
        }
    }
}

public class Observer : IObserver
{
    private Subject _subject;
    private int _state;

    public Observer(Subject subject)
    {
        _subject = subject;
        _subject.Attach(this);
    }

    public void Update(ISubject subject)
    {
        if (subject is Subject)
        {
            _state = ((Subject)subject).State;
        }
    }
}



In this example, the Subject class maintains a list of its observers and provides methods for adding or removing them from the list. The Subject's state is stored in the _state field, and its State property provides setter and getter access to the field. When the State property is set, the Notify() method is called, which iterates through the list of observers and calls the Update() method on each one. The Observer class implements the IObserver interface and provides an Update() method that updates its own _state field based on the state of the Subject.

In this way, the Observer pattern allows for a clean and flexible way to manage relationships between objects and propagate state changes. It is a widely used design pattern in software development and is worth considering when you need to implement similar functionality in your projects.