Article2 - Observer Pattern

原创 2006年05月21日 12:57:00

// This pattern defines a one-to-many dependency between objects so that when one object changes state,
// all its dependents are notified and updated automatically.
// Further, if use template to parameterize the type of class, we can get a more flexible implementation.

Here, I give a C# version implementation.

using System;
using System.Collections.Generic;
using System.Text;

namespace Observer
{
 // subject.cs
    interface ISubject
    {
        void RegisterObserver(Observer o);
        void RemoveObserver(Observer o);
        void NotifyObservers();
    }

    class WeatherStation : ISubject
    {
        public void RegisterObserver(Observer o)
        {
            if (o is Observer)
            {
                if (!listeners.Contains(o))
                    listeners.Add(o);
            }
        }

        public void RemoveObserver(Observer o)
        {
            if (o is Observer)
                listeners.Remove(o);
        }

        public void NotifyObservers()
        {
            if (isChanged)
            {
                foreach (Observer o in listeners)
                    o.Update(temperature, humidity, pressure);
            }
            isChanged = false;
        }

        private void SetChanged()
        {
            isChanged = true;
        }

        public float GetTemperature()
        {
            return temperature;
        }

        public float GetHumidity()
        {
            return humidity;
        }

        public float GetPressure()
        {
            return pressure;
        }

        public void SetElements(float t, float h, float p)
        {
            temperature = t;
            humidity = h;
            pressure = p;
            SetChanged();
            NotifyObservers();
        }

        public WeatherStation()
        {
            listeners = new List<Observer>();
            temperature = 0;
            humidity = 0;
            pressure = 0;
            isChanged = false;
        }

        private List<Observer> listeners;
        private float temperature;
        private float humidity;
        private float pressure;
        private bool isChanged;
    }

 // Observer.cs

  interface Observer
    {
        void Update(float t, float h, float p);

    }

    interface DisplayElement
    {
        void Display();
    }

    class ObserverOne : Observer, DisplayElement
    {
        public ObserverOne(ISubject s)
        {
            temperature = 0;
            humidity = 0;
            aSubject = s;
            aSubject.RegisterObserver(this);
        }
 
     public void Update(float t, float h, float p)
        {
            temperature = t;
            humidity = h;
      Display();
     }

     public void Display()
        {
      Console.WriteLine("ObserverOne: Temperature: {0}/tHumidity: {1}", temperature, humidity);
     }

        public void RegisterMyself()
        {
            aSubject.RegisterObserver(this);
        }

        public void RemoveMyself()
        {
            aSubject.RemoveObserver(this);
        }

     private float temperature;
     private float humidity;
        private ISubject aSubject;
    }

    class ObserverTwo : Observer, DisplayElement
    {
        public ObserverTwo(ISubject s)
        {
            temperature = 0;
            pressure = 0;
            aSubject = s;
            aSubject.RegisterObserver(this);
        }
 
        public void Update(float t, float h, float p)
        {
            temperature = t;
            pressure = p;
      Display();
     }

     public void Display()
        {
      Console.WriteLine("ObserverTwo: Temperature: {0}/tPressure: {1}", temperature, pressure);
     }

                public void RegisterMyself()
        {
            aSubject.RegisterObserver(this);
        }

        public void RemoveMyself()
        {
            aSubject.RemoveObserver(this);
        }

     private float temperature;
     private float pressure;
        private ISubject aSubject;
    }

 // main program
 class Program
    {
        static void Main(string[] args)
        {
            WeatherStation aData = new WeatherStation();
            ObserverOne aOne = new ObserverOne(aData);
            ObserverTwo aTwo = new ObserverTwo(aData);

            aData.SetElements(23.0f, 10.1f, 0.7f);
           
            aOne.RemoveMyself();
            aTwo.RegisterMyself();
            aOne.RegisterMyself();

            aData.SetElements(18.0f, 7.7f, 0.3f);
        }
    }
}

 

Either an interface implemetation or an inheritance impplemetation is still imperfect. Both of them have some flaws. For details pls refer to "Head First Design Pattern" chapter2.

设计模式笔记——(三:观察者模式 Observer Pattern)

观察者模式(Observer Pattern):定义对象之间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅(Publish/...
  • xiaoyu_93
  • xiaoyu_93
  • 2016年11月18日 15:38
  • 821

设计模式总结之Observer Pattern(观察者模式)

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。...
  • cooldragon
  • cooldragon
  • 2016年08月11日 00:53
  • 848

设计模式 - 观察者模式(Observer Pattern) 详解

观察者模式(Observer Pattern) 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/details/26583157 版权...
  • u012515223
  • u012515223
  • 2014年05月22日 14:37
  • 2911

设计模式之观察者模式 (Observer Design Pattern)

一、什么是观察者模式观察者定义了一种一对多的依赖关系,当一个主题(Subject)对象状态发生变化时,所有依赖它的相关对象都会得到通知并且能够自动更新自己的状态,这些依赖的对象称之为观察者(Obser...
  • suifeng3051
  • suifeng3051
  • 2016年04月27日 19:32
  • 902

观察者模式(Observer Pattern)

设计原理4:为了交互对象之间的松耦合设计而努力 观察者模式:定义了对象之间的一对多的依赖,这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。 案例:类似于邮件主...
  • wyzxk888
  • wyzxk888
  • 2013年06月30日 17:18
  • 727

观察者模式(Observer Pattern)

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己. 模式结构 观察者模式的好处: ...
  • lhc2207221755
  • lhc2207221755
  • 2014年03月21日 09:41
  • 1958

观察者模式(Observer Pattern)

java设计模式 观察者模式
  • u011066648
  • u011066648
  • 2017年04月12日 15:33
  • 193

观察者模式(Observer Pattern)

观察者设计模式也叫做发布-订阅(Publish-Subscribe)模式。有点像杂志订阅的意思,你向杂志社订阅杂志,然后提供了自己的姓名和邮箱地址,这样杂志社就可以把你所订阅的杂志推送到你的邮箱了,而...
  • u014161864
  • u014161864
  • 2015年01月23日 08:54
  • 2711

Observer Pattern 在C#是怎么使用的(一)

最近很少加班,晚上回家闲来无聊就拿起侯捷老师的《design pattern》 重读了起来。上侯捷老师的设计模式的课是差不多两年前的事了,也还记得考试的时候每个人都带着他的书放到书桌下面一顿狂抄。 ...
  • shizhangfan
  • shizhangfan
  • 2015年11月24日 16:48
  • 111

观察者模式(Observer Pattern)

观察者模式(Observer Pattern)观察者模式(Observer Pattern)也叫发布订阅模式(Publish/subscribe),它是一个在项目中经常 的模式,其定义如下: ...
  • baiuterfkcyj
  • baiuterfkcyj
  • 2017年05月06日 12:29
  • 63
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Article2 - Observer Pattern
举报原因:
原因补充:

(最多只允许输入30个字)