Design patterns: Observer

Design patterns (4 part series)

Design patterns: Singleton

Design patterns: Factory

Design patterns: Observer

Design patterns: Decorator

Wassup! This is the third post that I’m writing while learning design patterns. My first two posts covered creational design patterns. This time we’ll be taking a look at the observer pattern that is a behavioral pattern. I’ll first give a definition of the pattern, then show its implementation in C#, and finish with a code example.

Overview

Definition
Implementation
Example

Definition

Observer: a thing that watches or notices something.

The observer pattern allows us to create a one-to-many relationship between objects so that when one object changes, the many objects observing it will be notified and update accordingly.

In this pattern, there is one subject and many observers. The subject holds whatever state is of interest and notifies the observers when the state changes. Each observer keeps a reference to the subject, stores the state that should be consistent with the subject’s, and implements the observer updating the interface to keep the state consistent with that of the subject.

Implementation

To achieve the observer pattern, there are four types of classes we need to implement:

Subject
- Stores a List of its Observer objects.
- Defines the Attach, Detach, and Notify methods.
- Notifies the observers when the state changes.
ConcreteSubject
- Holds the state.
Observer
- Defines an Update interface.
ConcreteObserver
- Implements the Update interface.
- Stores reference to the ConcreteSubject.
- Stores state that should stay consistent with the ConcreteSubject.

Using C#, the pattern looks like this:

using System;
using System.Collections.Generic;
public class Program
{
    public static void Main()
    {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer = new ConcreteObserver(subject);
        subject.Attach(observer);
        subject.SomeState = 100;
        subject.Notify();
    }
}
// 1. Subject
abstract class Subject
{
    List<Observer> observers = new List<Observer>();
    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }
    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }
    public void Notify()
    {
        foreach (var observer in this.observers)
        {
            observer.Update();
        }
    }
}
// 2. Concrete Subject
class ConcreteSubject : Subject
{
    public int SomeState { get; set; }
}
// 3. Observer
abstract class Observer
{
    public abstract void Update();
}
// 4. Concrete Observer
class ConcreteObserver : Observer
{
    public int ObserverState { get; set; }
    ConcreteSubject MySubject { get; set; }
    public ConcreteObserver(ConcreteSubject subject)
    {
        this.MySubject = subject;
    }
    public override void Update()
    {
      this.ObserverState = MySubject.SomeState;
        Console.WriteLine("My state has been updated: " + this.ObserverState);
    }
}

using System;
using System.Collections.Generic;
public class Program
{
    public static void Main()
    {
        BasketballPlayer damianLillard = new BasketballPlayer("Damian Lillard");
        BasketballFan basketballFan1 = new BasketballFan(damianLillard);
        damianLillard.Attach(basketballFan1);
        damianLillard.Score(3);
        BasketballFan basketballFan2 = new BasketballFan(damianLillard);
        damianLillard.Attach(basketballFan2);
        damianLillard.Score(2);
    }
    abstract class Player
    {
        List<Fan> fans = new List<Fan>();
        public void Attach(Fan f)
        {
            fans.Add(f);
        }
        public void Detach(Fan f)
        {
            fans.Remove(f);
        }
        public void Notify()
        {
          foreach(Fan f in fans)
            {
                f.Update();
            }
        }
    }
    class BasketballPlayer : Player
    {
        public string Name;
        public int Points = 0;
        public BasketballPlayer(string name)
        {
            this.Name = name;
        }
        public void Score(int points)
        {
            this.Points += points;
            this.Notify();
        }
    }
    abstract class Fan
    {
        public abstract void Update();
    }
    class BasketballFan : Fan
    {
        BasketballPlayer FavoritePlayer;
        int FavoritePlayerPoints;
        public BasketballFan(BasketballPlayer player)
        {
          this.FavoritePlayer = player;
            this.FavoritePlayerPoints = this.FavoritePlayer.Points;
        }
        public override void Update()
        {
            this.FavoritePlayerPoints = this.FavoritePlayer.Points;
            Console.WriteLine(this.FavoritePlayer.Name + " has " + this.FavoritePlayerPoints + " points!");
        }
    }
}

Attributions:

undefined by undefined

License: Creative Commons-Attribution-ShareAlike 4.0 (CC-BY-SA 4.0)

Learn in-demand tech skills in half the time

PRODUCTS

Mock Interview

New

Courses

Skill Paths

Projects

Assessments

Design patterns: Observer

Overview

Definition

Implementation

Example