Reader Level:
Design Patterns & Practices

Observer Design Pattern in C#

By Jean Paul on Jun 10, 2011
In this article I am trying to implement the Observer design pattern. There are numerous articles on this pattern, even though I found interesting to create one.


The Gang of Four book (Design Patterns: Elements of Reusable Object-Oriented Software, 1995) says that the Observer design pattern should "Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically."

Purpose of Observer Pattern

The Observer pattern is to notify the interested observers about some change occurred. We can add more observers in runtime as well as remove them.

Example: We have a form to select the color. For each color change we need to update the entire application. There will be observers listening to the color change event for updating themselves.

Subject and Observers

The two important key terms in the pattern are Subject and Observer.

Subject is the object which holds the value and takes responsibility in notifying the observers when the value is changed. The subject could be a database change, property change or so.

We can conclude that the subject contains the following method implementations.

public interface ISubject
    void Register(IObserver observer);
    void Unregister(IObserver observer);

    void Notify();

The Observer is the object listening to the subject's change. Basically it will be having its own updating/calculating routine that runs when get notified.

public interface IObserver
    void ColorChanged(Color newColor);

In the above example, we are using an observer interface which has a ColorChanged method. So the interested observers should implement this interface to get notified.

There will be only one Subject and multiple number of Observers.

Registering and Unregistering

In the above interface, the observer can use the Register() method to get notified about changes . Anytime, it can unregister about notifications using the Unregister() method.


The Notify() method will take care of calling the listening observers.


The Subject and Observer objects will be having a one-to-many association.


Using the Code

The associated code is having a main form, where the Subject would be a class named ColorSubject.

public class ColorSubject : ISubject
    private Color _Color = Color.Blue;

    public Color Color
        get { return _Color; }
            _Color = value;

    #region ISubject Members

    private HashSet<IObserver> _observers = new HashSet<IObserver>();

    public void Register(IObserver observer)

    public void Unregister(IObserver observer)

    public void Notify()
        _observers.ToList().ForEach(o => o.ColorChanged(Color));

The class implements ISubject interface and thus takes care of registering, unregistering and notifying the interested observers. All the observers keep registered with the ColorSubject object.

Screen Shot of Application


On running the associated project, we can see a color selector form, which acts as as the subject. All the other forms are observers listening to the ColorChanged event.

Note: The multicast event model in .Net can also be considered as an observer pattern. Here the interested parties register a method with the subject (might be a button) and whenever the button is clicked (an event) it invokes the registered observers (subscribers)


In this article we have seen what Observer pattern is and an example implementation.