大话设计模式之观察者模式+事件委托学习

从零开始，先是设计模式

Subject：发送方的接口【作为发送方必须有发送消息的指令(Noify),观察者模式还让发送方另外充当了一个记录观察者的这样一个角色(Attach[增加观察者])(Dtach[删除观察者]),每次执行发送指令的时候就遍历执行自身所记录下来的观察者们的执行方法。】
ConcretSubject：发送方的具体实现类
Observer：接收方的接口【作为接收方必须有接收消息的要实现的方法（Update)】
ConcretObserver：接收方的具体实现类

  abstract class Subject
    {
      private IList<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();
          }
      }  
  }    
  class ConsretSubject:Subject
    {
        //具体被观察者的状态
        private string subjectState;        
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
      
    }
    abstract class Observer
    {
        public abstract void Update();
    }
    class ConcreteObserver: Observer
    {
        private string name;
        private string observerState;
        private ConsretSubject subject;        
        internal ConsretSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }
        public ConcreteObserver(string name, ConsretSubject subject)
        {
            this.name = name;
            this.subject = subject;
        }
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("观察者{0}收到，发送者的新状态是{1}", name, observerState);
        }   
    }

执行：

这样做有个不好的地方，发送方需要记录存储所有监听对象从而遍历执行对应的方法。其实不需要这样做，在发送方执行发送消息指令的时候，只需要获取到接收方对应的执行方法即可。 这里需要发送方与接收方解耦，只保留单向关系。让接收对象依赖监听对象，监听对象不依赖接收对象。

事件委托

 interface Subject
    {
       void Notify();
      
      string SubjectState
      {
          get;
          set;
      }
    }
   public delegate void EventHandler();
    class ConsretSubject:Subject
    {
       
        private string subjectState;     
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
        //事件
        public event EventHandler Update;
        public void Notify()
        {
            Update();
        }
      
    }
    class StockObserver
    {
        private string name;
        private Subject subject;       
        public StockObserver(string name, Subject subject)
        { 
            this.name = name;
            this.subject = subject;
        }
        public void CloseStockMarket()
        {
           
            Console.WriteLine("{0}{1} 关闭股票行情，继续工作", subject.SubjectState,name);
        }   
    }
    class NBAObserver
     {
        private string name;
        private Subject subject;        
        public NBAObserver(string name, Subject subject)
        {
            this.name = name;
            this.subject = subject;
        }
        public void CloseNBAMarket()
        {           
         Console.WriteLine("{0}{1} 关闭NBA，继续工作", subject.SubjectState, name);
        }
    }

执行：

用事件委托的方式实现部分解耦。这样做也有不足，就是执行的方法(函数)必须保证是一样类型的返回值和参数。在MVC框架中就是用Object 类型作为参数去传值给UI层执行不同的方法，涉及到装箱拆箱…哎具体情况具体分析吧。