C# 观察者模式

观察者模式

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

结构图：

                 

代码：

  

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

namespace 观察者模式
{
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(IObserver observer);
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }
    class Boss : Subject
    {
        private IList<IObserver> observers = new List<Observer>();
        private string action;
        public void Attach(IObserver observer)
        {
            observers.Add(observer);
        }
        public void Detach(IObserver observer)
        {
            observers.Remove(observer);
        }
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
        public string SubjectState
        {
            get {return action; }
            set {action=value; }
        }
    }
    abstract class Observer
    {
        protected string name;
        protected Subject sub;
        public Observer(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public abstract void Update();
    }
    class StockObserver : Observer
    {
        public StockObserver(string name, Subject sub)
        {
            :base(name,sub)
                {
                }
public override void Update()
        {
            Console.WriteLine("{0},{1}关闭股票行情，继续工作！",sub.SubjectState ,name);
        }

    }
    }
    class Program
    {
        static void Main(string[] args)
        {
        Boss huhansan = new Boss();
        StockObserver tongshi1 = new StockObserver("aaa", huhansan);
        NBAObserver tongshi2 = new NBAObserver("bbb"，huhansan);
        huhansan.Attach(tongshi1);
        huhansan.Attach(tongshi2);
        huhansan.Detach(tongshi1);
        huhansan.SubjectState = "我胡汉三 又回来了";
        huhansan.Notify();
        }
    }
}

总结：

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