C#学习笔记-观察者模式

题目1：几个同事为了在上班期间偷偷看休息，做点其他的事情，就和小秘偷偷联系了一下，如果老板回来了，就麻烦小秘偷偷通知一声，这样方便大家及时变更自己的工作状态。

分析：

　　根据题目分析，首先明确，肯定会有两个类：小秘类和同事类，分别描述与记录两种类型的人和行为。

　　需要注意的是：小秘与同事构建联系的时候，一个小秘可能对应多位同事，所以这时需要利用List<>。

实现：

    class Program
    {
        static void Main(string[] args)
        {
            Secretary lady = new Secretary();
            StockObserver num1 = new StockObserver("A", lady);
            StockObserver num2 = new StockObserver("B", lady);

            lady.Attach(num1);
            lady.Attach(num2);

            lady.SecretAction="boss is back";
            lady.Notify();

            Console.Read();
        }
    }

    /// <summary>
    /// 小秘
    /// 1.记下需要联系的同事们List<StockObserver>
    /// 2.增加需要联系的人员
    /// 3.减少联系人员（有可能没有通知到，有可能人员辞职等）
    /// 4.秘密通知同事，老板回来了
    /// </summary>
    class Secretary
    {
        IList<StockObserver> stockOb = new List<StockObserver>();
        private string action;

        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        //增加需要联系的人员
        public void Attach(StockObserver ob)
        {
            stockOb.Add(ob);
        }

        //减少需要联系的人员
        public void Detach(StockObserver ob)
        {
            stockOb.Remove(ob);
        }

        //小秘通知了同事后，同事赶紧自行更改工作状态
        public void Notify()
        {
            foreach (StockObserver o in stockOb)
                o.Update();
        }
    }

    /// <summary>
    /// 看股票的同事
    /// 1.联系小秘，和小秘保持良好关系
    /// 2.根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class StockObserver
    {
        private string name;
        private Secretary sec;

        public StockObserver(string name,Secretary sec)
        {
            this.name = name;
            this.sec = sec;
        }
        public void Update()
        {
            Console.WriteLine("{0} {1} 关闭股票行情，继续工作！", sec.SecretAction, name);
        }
    }

题目2：由于同事们人数众多，所以大家休闲的方式并不一致。

分析：

　　同事们的休闲方式不同，他们彼此之间存在共同点与不同点。

　　他们的共同点在于都需要与小秘联系且更新工作状态，同时他们的不同点也在于更新工作状态。

　　所以相同点就不需要在子类中赘述，所以通过抽象类来将不同的方法设为抽象即可。

实现：

    class Program
    {
        static void Main(string[] args)
        {
            Secretary lady = new Secretary();
            StockObserver num1 = new StockObserver("A", lady);
            NBAObserver num2 = new NBAObserver("B", lady);

            lady.Attach(num1);
            lady.Attach(num2);

            lady.SecretAction = "boss is back";
            lady.Notify();

            Console.Read();
        }
    }

    /// <summary>
    /// 小秘
    /// 1.记下需要联系的同事们List<StockObserver>
    /// 2.增加需要联系的人员
    /// 3.减少联系人员（有可能没有通知到，有可能人员辞职等）
    /// 4.秘密通知同事，老板回来了
    /// </summary>
    class Secretary
    {
        IList<Observers> observers = new List<Observers>();
        private string action;

        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        //增加需要联系的人员
        public void Attach(Observers ob)
        {
            observers.Add(ob);
        }

        //减少需要联系的人员
        public void Detach(Observers ob)
        {
            observers.Remove(ob);
        }

        //小秘通知了同事后，同事赶紧自行更改工作状态
        public void Notify()
        {
            foreach (Observers o in observers)
                o.Update();
        }
    }

    /// <summary>
    /// 观察者类
    /// 抽象类
    /// 偷偷玩的同事的状态都不同，他们的共同点就是1.与小秘联系，2.更新工作状态
    /// 不同点在于更新状态前不同，所以更新工作状态设置为抽象方法即可
    /// </summary>
    abstract class Observers
    {
        protected string name;
        protected Secretary sec;

        public  Observers(string name,Secretary sec)
        {
            this.name = name;
            this.sec = sec;
        }

        public abstract void Update();
    }


    /// <summary>
    /// 看股票的同事
    /// 继承于观察者类
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class StockObserver:Observers
    {
        public StockObserver(string name, Secretary sec) 
            : base(name, sec)
        {
        }

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

    /// <summary>
    /// 看NBA节目的同事
    /// 继承于观察者类
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class NBAObserver : Observers
    {
        public NBAObserver(string name, Secretary sec) 
            : base(name, sec)
        {
        }

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

题目3：如果小秘突然有事情变得特别忙的时候，就没有了通知者，而此刻老板突然回来了，所以老板本身就变成了临时的通知者。

分析：

　　老板本身变成了临时的通知者，虽然这个故事很不幸，但是客观分析，此刻老板的作用于小秘是一样的，所以老板应该和小秘继承于同一种父类。

　　由于老板需要与观察者联系，而此刻的观察者已是抽象类，所以老板的父类不能再为抽象类了。

　　原因如下：

　　

　　故此，老板和小秘只能通过接口来实现了。

实现：

    class Program
    {
        static void Main(string[] args)
        {
            Boss boss = new Boss();


            Secretary lady = new Secretary();
            StockObserver num1 = new StockObserver("A", lady);
            NBAObserver num2 = new NBAObserver("B", lady);

            //lady没来的及通知两位同事
            lady.Detach(num1);
            lady.Detach(num2);

            //现在的通知者就变成了boss
            boss.Attach(num1);
            boss.Attach(num2);

            //num2没有看见boss回来，所以boss没来的及通知他
            boss.Detach(num2);

            boss.SecretAction = "boss is back";
            boss.Notify();

            Console.Read();
        }
    }

    /// <summary>
    /// 通知者的接口
    /// 不能用抽象类
    /// </summary>
    interface Subject
    {
        void Attach(Observers ob);
        void Detach(Observers ob);
        void Notify();
        string SecretAction
        {
            get;set;
        }
    }

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

        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        //增加需要联系的人员
        public void Attach(Observers ob)
        {
            observers.Add(ob);
        }

        //减少需要联系的人员
        public void Detach(Observers ob)
        {
            observers.Remove(ob);
        }

        //大家看见boss回来后，同事赶紧自行更改工作状态
        public void Notify()
        {
            foreach (Observers o in observers)
                o.Update();
        }
    }

    /// <summary>
    /// 小秘：继承于接口
    /// 1.记下需要联系的同事们List<StockObserver>
    /// 2.增加需要联系的人员
    /// 3.减少联系人员（有可能没有通知到，有可能人员辞职等）
    /// 4.秘密通知同事，老板回来了
    /// </summary>
    class Secretary:Subject
    {
        IList<Observers> observers = new List<Observers>();
        private string action;
        
        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        //增加需要联系的人员
        public void Attach(Observers ob)
        {
            observers.Add(ob);
        }

        //减少需要联系的人员
        public void Detach(Observers ob)
        {
            observers.Remove(ob);
        }

        //小秘通知了同事后，同事赶紧自行更改工作状态
        public void Notify()
        {
            foreach (Observers o in observers)
                o.Update();
        }
    }

    /// <summary>
    /// 观察者类
    /// 抽象类
    /// 偷偷玩的同事的状态都不同，他们的共同点就是1.与小秘联系，2.更新工作状态
    /// 不同点在于更新状态前不同，所以更新工作状态设置为抽象方法即可
    /// </summary>
    abstract class Observers
    {
        protected string name;
        protected Secretary sec;

        public Observers(string name, Secretary sec)
        {
            this.name = name;
            this.sec = sec;
        }

        public abstract void Update();
    }


    /// <summary>
    /// 看股票的同事
    /// 继承于观察者类
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class StockObserver : Observers
    {
        public StockObserver(string name, Secretary sec)
            : base(name, sec)
        {
        }

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

    /// <summary>
    /// 看NBA节目的同事
    /// 继承于观察者类
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class NBAObserver : Observers
    {
        public NBAObserver(string name, Secretary sec)
            : base(name, sec)
        {
        }

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

附：

实现：

    class Program
    {
        static void Main(string[] args)
        {
            Boss boss = new Boss();
            Secretary lady = new Secretary();

            StockObserver num1 = new StockObserver("A", boss);
            NBAObserver num2 = new NBAObserver("B", boss);
            
            //将“看股票”的“关闭股票程序”方法和“看NBA者”的“关闭NBA直播”的方法
            //挂钩到老板的“更新”上，也就是将两种不同类的不同方法委托给老板类的更新了。
            boss.Update += new EventHandler(num1.CloseStockMarket);
            boss.Update += new EventHandler(num2.CloseNBADirectSeeding);

            boss.SecretAction = "boss is back";
            boss.Notify();

            Console.Read();
        }
    }

    /// <summary>
    /// 通知者的接口
    /// 不能用抽象类
    /// 现在抽象通知者由于不下网依赖抽象观察者，所以“增加”和“减少”的方法就没有必要了
    /// </summary>
    interface Subject
    {
        void Notify();
        string SecretAction
        {
            get; set;
        }
    }

    /// <summary>
    /// 委托就是一种引用方法的类型。
    /// 一旦为委托分配了方法，委托将于该方法具有完全相同的行为
    /// 委托方法的使用可以像任何其他方法一样，具有参数和返回值。
    /// 委托可以看做是对函数的抽象，是函数的‘类’，委托的实例将代表一个具体的函数
    /// 
    /// 一个委托可以搭载多个方法，所有的方法被依次唤起
    /// 最重要的是，它可以使得委托对象所搭载的方法并不需要属于同一个类
    /// 
    /// 委托对象所搭载的所有方法必须具有相同的原型和形式，也就是有相同的参数列表和返回值类型
    /// </summary>
    delegate void EventHandler();   //委托

    class Boss : Subject
    {
        public event EventHandler Update;

        private string action;

        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        //大家看见boss回来后，同事赶紧自行更改工作状态
        public void Notify()
        {
            Update();
        }
    }

    /// <summary>
    /// 小秘：继承于接口
    /// 1.记下需要联系的同事们List<StockObserver>
    /// 2.增加需要联系的人员
    /// 3.减少联系人员（有可能没有通知到，有可能人员辞职等）
    /// 4.秘密通知同事，老板回来了
    /// </summary>
    class Secretary : Subject
    {
        public event EventHandler Update;

        private string action;

        public string SecretAction
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }
        

        //小秘通知了同事后，同事赶紧自行更改工作状态
        public void Notify()
        {
            Update();
        }
    }
    
    /// <summary>
    /// 看股票的同事
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class StockObserver 
    {
        private string name;
        private Subject sub;

        public StockObserver(string name,Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }

        public  void CloseStockMarket()
        {
            Console.WriteLine("{0} {1} 关闭股票行情，继续工作！", sub.SecretAction, name);
        }
    }

    /// <summary>
    /// 看NBA节目的同事
    /// 根据小秘的偷偷通知修改自己的工作状态
    /// </summary>
    class NBAObserver 
    {
        private string name;
        private Subject sub;

        public NBAObserver(string name,Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }

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

 总结：

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

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

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

　　一个委托可以搭载多个方法，所有方法被依次唤起。

　　委托对象所搭载的方法并不需要属于同一个类。

注：文中所有代码及知识点均来自于《大话设计模式》,本人属于边学边看边敲代码边总结的阶段。