Jean Paul's Blog

There are 2 types of People in the World, One who Likes SharePoint and..

  • Microsoft MVP

  • MindCracker MVP

  • CodeProject MVP

  • eBook on SharePoint 2010

  • eBook on Design Patterns

  • eBook on Windows Azure

  • NLayers Framework @ CodePlex

  • MSDN Forums

  • .Net vs. Java

    Due to Public Demand

Observer Design Pattern in C#

Posted by Jean Paul on November 13, 2011

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.  The associated source code can be found here.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s