【设计模式】观察者模式(observer)c#/python实现

   

定义

定义对象间的一种一对多的依赖关系，等一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动更新

   

ｃ＃代码，没有严格按照四人帮的Ｕｍｌ

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

namespace DesignPatterns
{
    /// <summary>
    /// The 'Subject' abstract class
    /// 目标对象,它知道观察它的观察者,并提供注册和删除观察者的接口
    /// </summary>
    abstract class Subject
    {
        //用来保存,观察者的对象
        private 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 (Observer o in _observers)
            {
                o.Update(this);
            }
        }
    }

    /// <summary>
    /// The 'ConcreteSubject' class
    /// 具体的目标对象,维护目标对象的状态
    /// 当自己的状态发生变化时,负责通知各个观察者
    /// </summary>
    class ConcreteSubject : Subject
    {
        private string _subjectState;

        // Gets or sets subject state
        public string SubjectState
        {
            get 
            { 
                return _subjectState; 
            }
            set 
            { 
                _subjectState = value;
                //状态发生变化，通知各个观察者
                this.Notify(); 
            }
        }
    }

    /// <summary>
    /// The 'Observer' abstract class
    /// 观察者，定义个接口，给那些在目标发生改变的时候被通知的对象
    /// </summary>
    abstract class Observer
    {
        public abstract void Update(Subject subject);
    }

    /// <summary>
    /// The 'ConcreteObserver' class
    /// 具体的观察者，实现更新的方法，使自身的状态也目标状态保持一致
    /// </summary>
    class ConcreteObserver : Observer
    {
        private string _name;
        private string _observerState;

        // Constructor
        public ConcreteObserver(string name)
        {
            this._name = name;
        }

        public override void Update(Subject subject)
        {
            _observerState = ((ConcreteSubject)subject).SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}",
              _name, _observerState);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Configure Observer pattern
            ConcreteSubject s = new ConcreteSubject();

            s.Attach(new ConcreteObserver("X"));
            s.Attach(new ConcreteObserver("Y"));
            s.Attach(new ConcreteObserver("Z"));

            // Change subject and notify observers
            s.SubjectState = "ABC";

            // Wait for user
            Console.ReadKey();

            // Change subject and notify observers
            s.SubjectState = "CBA";

            // Wait for user
            Console.ReadKey();
        }
    }
}

 python 代码

class Subject(object):
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        if not observer in self._observers:
            self._observers.append(observer)

    def detach(self, observer):
        try:
            self._observers.remove(observer)
        except ValueError:
            pass

    def notify(self, modifier=None):
        for observer in self._observers:
            if modifier != observer:
                observer.update(self)


# Example usage
class Data(Subject):
    def __init__(self, name=''):
        super(Data,self).__init__()
        self.name = name
        self._data = 0

    @property
    def data(self):
        return self._data
    
    @data.setter
    def data(self,value):
        self._data = value
        self.notify()
        
class HexViewer:
    def update(self, subject):
        print 'HexViewer: Subject %s has data 0x%x' % (subject.name, subject.data)


class DecimalViewer:
    def update(self, subject):
        print 'DecimalViewer: Subject %s has data %d' % (subject.name, subject.data)


# Example usage...
def main():
    data1 = Data('Data 1')
    data2 = Data('Data 2')
    view1 = DecimalViewer()
    view2 = HexViewer()
    data1.attach(view1)
    data1.attach(view2)
    data2.attach(view2)
    data2.attach(view1)

    print "Setting Data 1 = 10"
    data1.data = 10
    print "Setting Data 2 = 15"
    data2.data = 15
    print "Setting Data 1 = 3"
    data1.data = 3
    print "Setting Data 2 = 5"
    data2.data = 5
    print "Detach HexViewer from data1 and data2."
    data1.detach(view2)
    data2.detach(view2)
    print "Setting Data 1 = 10"
    data1.data=10
    print "Setting Data 2 = 15"
    data2.data=15

if __name__ == '__main__':
    main()