《大话设计模式》--老板回来，我不知道--观察者模式<Observer>(14)

UML图：

interface ISubject
    {
        string SubjectName
        {
            get;
            set;
        }

        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
    }

 

class Boss : ISubject
    {
        private IList<Observer> observers = new List<Observer>();
        private string action;

        public string SubjectName
        {
            get { return action; }
            set { action = value; }
        }

        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();
            }
        }
    }

 

class Secretary:ISubject
    {
        private IList<Observer> observers = new List<Observer>();
        private string action;

        public string SubjectName
        {
            get { return action; }
            set { action = value; }
        }

        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();
            }
        }        
    }

 

abstract class Observer
    {
        protected string name;
        protected ISubject isub;

        public Observer(string name, ISubject isub)
        {
            this.name = name;
            this.isub = isub;
        }

        public abstract void Update();
    }

 

class StockObserver:Observer
    {
        public StockObserver(string name, ISubject isub)
            : base(name, isub)
        { }

        public override void Update()
        {

            Console.WriteLine(string.Format("{0}{1}关闭股票行情，继续工作！", isub.SubjectName, name));
        }
    }

 

class NBAObserver : Observer
    {
        public NBAObserver(string name, ISubject isub)
            : base(name, isub)
        { }

        public override void Update()
        {
            Console.WriteLine(string.Format("{0}{1}关闭NBA直播，继续工作！", isub.SubjectName, name));
        }
    }

客户端代码： 

            Boss b = new Boss();
            StockObserver so = new StockObserver("Sum", b);
            NBAObserver nbaO = new NBAObserver("Ark", b);

            b.Attach(so);
            b.Attach(nbaO);

            b.Detach(nbaO);

            b.SubjectName = "I'm come back!\n";
            b.Notify();

 

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

特点：将一个系统分割成一系列相互协作的类有一个不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。

When use?

当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少个对象有待改变时，应该考虑使用观察者模式。

一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立改变和复用。总的来说，观察者模式所做的工作其实就是解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

 

事件委托实现： 

   interface ISubject
    {
        string SubjectName
        {
            get;
            set;
        }

        void Notify();
    }

 

 class Boss : ISubject
    {
        public event EventHandler Update;
        public delegate void EventHandler();

        private string action;

        public string SubjectName
        {
            get { return action; }
            set { action = value; }
        }      

        public void Notify()
        {
            Update();
        }
    }

 

class Secretary : ISubject
    {
        public event EventHandler Update;
        public delegate void EventHandler();
        private string action;

        public string SubjectName
        {
            get { return action; }
            set { action = value; }
        }

        public void Notify()
        {
            Update();
        }
    }

 

 

class StockObserver
{
        private string name;
        private ISubject isub;
        public StockObserver(string name, ISubject isub)           
        {
            this.name = name;
            this.isub = isub;
        }

        public override void Update()
        {
            Console.WriteLine(string.Format("{0}{1}关闭股票行情，继续工作！", isub.SubjectName, name));
        }
}

 

  class NBAObserver
    {
        private string name;
        private ISubject isub;

        public NBAObserver(string name, ISubject isub)           
        {
            this.name = name;
            this.isub = isub;
        }

        public void CloseNBADirectSeeding()
        {
            Console.WriteLine(string.Format("{0}{1}关闭NBA直播，继续工作！", isub.SubjectName, name));
        }
    }

 

            Boss b = new Boss();

            StockObserver so = new StockObserver("Jeffi", b);
            NBAObserver nbao = new NBAObserver("Jaryk", b);

            b.Update += new Boss.EventHandler(so.CloseStockMarket);
            b.Update += new Boss.EventHandler(nbao.CloseNBADirectSeeding);

            b.SubjectName = "I'm come back!";

            b.Notify();

 

委托就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的“类”，委托的实例将代表一个具体的函数。

一个委托可以搭载多个方法，所有方法被依次唤起。它可以使委托对象所搭载的方法并不需要属于同一个类。

委托对象所搭载的所有方法必须具有相同的原形和形式，也就是拥有相同的参数列表和返回值类型。