#region Subject
public abstract class Subject
{
#region Members
private List<IObserver> _observers;
#endregion
#region Ctor
/// <summary>
/// Construct a new subject object
/// </summary>
public Subject()
{
_observers = new List<IObserver>();
}
#endregion
#region Methods
/// <summary>
/// Attaches a new observer to the subject
/// </summary>
/// <param name="observer">The observer to attach</param>
public void Attach(IObserver observer)
{
_observers.Add(observer);
}
/// <summary>
/// Detaches an observer from the subject
/// </summary>
/// <param name="observer">The observer to detach</param>
public void Detach(IObserver observer)
{
_observers.Remove(observer);
}
/// <summary>
/// Notify all the observers about the change in the
/// subject's state
/// </summary>
public void Notify()
{
foreach (IObserver observer in _observers)
{
observer.Update();
}
}
#endregion
}
#endregion
#region Concrete Subject
public class ConcreteSubject<T> : Subject
{
#region Properties
/// <summary>
/// The state of the subject
/// </summary>
public T SubjectState { get; set; }
#endregion
}
#endregion
#region Observer
public interface IObserver
{
void Update();
}
#endregion
#region Concrete Observer
public class ConcreteObserver<T> : IObserver
{
#region Properties
/// <summary>
/// The subject the observer holds
/// </summary>
public ConcreteSubject<T> Subject { get; set; }
private T _observerState;
#endregion
#region Ctor
/// <summary>
/// Construct a new concrete observer with the given
/// subject
/// </summary>
/// <param name="subject">The given subject</param>
public ConcreteObserver(ConcreteSubject<T> subject)
{
Subject = subject;
}
#endregion
#region IObserver Members
/// <summary>
/// Make an update to the observer state whenever the
/// method is callled
/// </summary>
public void Update()
{
_observerState = Subject.SubjectState;
Console.WriteLine("The new state of the observer:{0}",
_observerState.ToString());
}
#endregion
}
#endregion
The example is simple to follow. We have an IObserver interface and a
Subject abstract class. The observers are registered in the subject with the
Attach method and also can be detached. The subject implement the Notify
method that notifies every observer when the subject state was changed.
When the state changes the observer make an update which is the main
method of the IObserver interface.
ConcreteSubject<string> subject =
new ConcreteSubject<string>();
subject.Attach(new ConcreteObserver<string>(subject));
subject.Attach(new ConcreteObserver<string>(subject));
subject.SubjectState = "Hello World";
subject.Notify();
Console.Read();