Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Frequency of use: high
UML class diagram
Participants The classes and/or objects participating in this pattern are:
Subject(Stock)
knows its observers. Any number of Observer objects may observe a subject
provides an interface for attaching and detaching Observer objects.
ConcreteSubject(IBM)
stores state of interest to ConcreteObserver
sends a notification to its observers when its state changes
Observer(IInvestor)
defines an updating interface for objects that should be notified of changes in a subject.
ConcreteObserver(Investor)
maintains a reference to a ConcreteSubject object
stores state that should stay consistent with the subject's
implements the Observer updating interface to keep its state consistent with the subject's
Sample code in C#
This structural code demonstrates the Observer pattern in which registered objects are notified of and updated with a state change.
// Observer pattern -- Structural example
using System; using System.Collections; // "Subject" abstract class Subject { // Fields private ArrayList observers = new ArrayList(); // Methods public void Attach( Observer observer ) { observers.Add( observer ); } public void Detach( Observer observer ) { observers.Remove( observer ); } public void Notify() { foreach( Observer o in observers ) o.Update(); } } // "ConcreteSubject" class ConcreteSubject : Subject { // Fields private string subjectState; // Properties public string SubjectState { get{ return subjectState; } set{ subjectState = value; } } } // "Observer" abstract class Observer { // Methods abstract public void Update(); } // "ConcreteObserver" class ConcreteObserver : Observer { // Fields private string name; private string observerState; private ConcreteSubject subject; // Constructors public ConcreteObserver( ConcreteSubject subject, string name ) { this.subject = subject; this.name = name; } // Methods override public void Update() { observerState = subject.SubjectState; Console.WriteLine( "Observer {0}'s new state is {1}", name, observerState ); } // Properties public ConcreteSubject Subject { get { return subject; } set { subject = value; } } } /// <summary> /// Client test /// </summary> public class Client { public static void Main( string[] args ) { // Configure Observer structure ConcreteSubject s = new ConcreteSubject(); s.Attach( new ConcreteObserver( s, "X" ) ); s.Attach( new ConcreteObserver( s, "Y" ) ); s.Attach( new ConcreteObserver( s, "Z" ) ); // Change subject and notify observers s.SubjectState = "ABC"; s.Notify(); } }
Output
Observer X's new state is ABC Observer Y's new state is ABC Observer Z's new state is ABC
This real-world code demonstrates the Observer pattern in which registered investors are notified every time a stock changes value.
// Observer pattern -- Real World example
using System; using System.Collections; // "Subject" abstract class Stock { // Fields protected string symbol; protected double price; private ArrayList investors = new ArrayList(); // Constructor public Stock( string symbol, double price ) { this.symbol = symbol; this.price = price; } // Methods public void Attach( Investor investor ) { investors.Add( investor ); } public void Detach( Investor investor ) { investors.Remove( investor ); } public void Notify() { foreach( Investor i in investors ) i.Update( this ); } // Properties public double Price { get{ return price; } set{ price = value; Notify(); } } public string Symbol { get{ return symbol; } set{ symbol = value; } } } // "ConcreteSubject" class IBM : Stock { // Constructor public IBM( string symbol, double price ) : base( symbol, price ){} } // "Observer" interface IInvestor { // Methods void Update( Stock stock ); } // "ConcreteObserver" class Investor : IInvestor { // Fields private string name; private string observerState; private Stock stock; // Constructors public Investor( string name ) { this.name = name; } // Methods public void Update( Stock stock ) { Console.WriteLine( "Notified investor {0} of {1}'s " + change to {2:C}", name, stock.Symbol, stock.Price ); } // Properties public Stock Stock { get{ return stock; } set{ stock = value; } } } /// <summary> /// ObserverApp test /// </summary> public class ObserverApp { public static void Main( string[] args ) { // Create investors Investor s = new Investor( "Sorros" ); Investor b = new Investor( "Berkshire" ); // Create IBM stock and attach investors IBM ibm = new IBM( "IBM", 120.00 ); ibm.Attach( s ); ibm.Attach( b ); // Change price, which notifies investors ibm.Price = 120.10; ibm.Price = 121.00; ibm.Price = 120.50; ibm.Price = 120.75; } }
Output
Notified investor Sorros of IBM's change to $120.10 Notified investor Berkshire of IBM's change to $120.10 Notified investor Sorros of IBM's change to $121.00 Notified investor Berkshire of IBM's change to $121.00 Notified investor Sorros of IBM's change to $120.50 Notified investor Berkshire of IBM's change to $120.50 Notified investor Sorros of IBM's change to $120.75 Notified investor Berkshire of IBM's change to $120.75
Definition Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. Frequency of use: high UML class diagram