Observer Design Pattern
Many times when programming
we come across situation where by change in one change needs to be updated in
multiple object. For example if a parameter is used to make multiple calculation
in different objects then on change of that parameter all the objects need to be
notified of the change. Or for example
when the windows (operating system) or Dot Net framework shut downs or closes
then it notifies all the application running on it to close so that it can make
a clean close.
For this kind of situation the observer pattern was designed. In observer pattern there is a subject (also called observer) which maintains the list of all the dependent objects. In case of any change all the dependent objects are notified with the help of a call to one of the method. This is mainly helpful in distributed event handling. It creates a One 2 many relationships between the subject and the dependent objects (also called listener).
Normally the Subject
(Observer is defined like the one below)
abstract class aSubject
{
private List<IObserver> observers = new List<IObserver>();
// Abstract PropertyThe change of this
property will be notified to the observer
Public string strText
public void Attach(IObserver observer)
{
observers.Add(observer);
}
public void Detach(IObserver observer)
{
observers.Remove(observer);
}
public void Notify()
{
foreach (IObserver o in observers)
{
o.Update();
}
}
}
The abstract interface is very simple with only one method
All
the observer class will have to implement this method and will receive the
notification with the call to this method. If required the Observer class might
also raise an event inside the implementation of the Update method.
interface IObserver
{
// this method will be called on change
of the property
void Update();
}
The
abstract subject class does most of the work. The actual Subject (concrete class
will have only one small work of calling the Notify method on change of the
property.)
class ConcreteSubject
: Subject
{
public string _strText;
public string strText
{
get
{
return _strText;
}
set
{
_strText = value;
// Call the Notify method to
update all the observer
Notify();
}
}
}
The concrete Observer looks something like this.
class ConcreteObserver : IObserver
{
// Other Implementation of class
public void Update()
{
Console.WriteLine(“Notified”);
}
}
Vikram