设计模式之观察者模式

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主体对象。这个主体对象在状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自己。

　　观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响到另一边的变化。

下面的代码利用了委托。我对委托的定义就是函数指针。

 

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

namespace 观察者模式
{
    delegate void EventHandler();
    interface Object
    {
        string State
        {
            get;
            set;
        }
        void Notify();
    }
    class AObject:Object
    {
        private string state;
        public event EventHandler update;
        public string State
        {
            get
            {
                return state;
            }
            set
            {
                state = value;
            }
        }
        public void Notify()
        {
            update();
        }
    }
    class BObject : Object
    {
        private string state;
        public event EventHandler update;
        public string State
        {
            get
            {
                return state;
            }
            set
            {
                state = value;
            }
        }
        public void Notify()
        {
            update();
        }
    }
    class ManA
    {
        public string name;
        public Object obj;
        public ManA(string Name,Object Obj)
        {
            this.name = Name;
            this.obj = Obj;
        }
        public void updateA()
        {
            Console.WriteLine("{0},{1},关掉电视",obj.State,name);
        }
    }
    class ManB
    {
        public string name;
        public Object obj;
        public ManB(string Name,Object Obj)
        {
            this.name = Name;
            this.obj = Obj;
        }
        public void updateB()
        {
            Console.WriteLine("{0},{1},关掉手机",obj.State,name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AObject a = new AObject();
            a.State = "我是A";
            ManA am = new ManA("am", a);
            ManB bm = new ManB("bm", a);
            a.update += new EventHandler(am.updateA);
            a.update += new EventHandler(bm.updateB);
            a.Notify();
            BObject b = new BObject();
            b.State = "我是B";
            ManA cm = new ManA("cm", b);
            ManB dm = new ManB("dm",b);
            b.update += new EventHandler(cm.updateA);
            b.update += new EventHandler(dm.updateB);
            b.Notify();
            Console.Read();
        }
    }
}

 

输出结果：