设计模式的故事---观察者模式

意图：

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

适用性：

当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

 模拟一个《奔跑吧兄弟》中 撕名牌 的游戏

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

namespace DesignerModel.Observer
{
    public abstract class IObserver
    {
        public abstract void Update(string msg);
    }
    /// <summary>
    /// 大广播
    /// </summary>
    public class Subject
    {
        private List<Observer> observers = new List<Observer>();

        public void Attach(Observer o)
        {
            observers.Add(o);
        }
        public void Detach(Observer o)
        {
            observers.Remove(o);
        }

        public void NotifyObservers(string msg)
        {
            foreach (var item in observers)
            {
                item.Update(msg);
            }
        }

    }
    /// <summary>
    /// 游戏者
    /// </summary>
    public class Observer : IObserver
    {
        public Observer(string name)
        {
            Name = name;
        }
        public string Name { get; set; }

        public override void Update(string msg)
        {
            Console.WriteLine(this.Name + "收到信息:" + msg);
        }
        public string CreateNum()
        {
            RNGCryptoServiceProvider csp = new RNGCryptoServiceProvider();
            byte[] byteCsp = new byte[10];
            csp.GetBytes(byteCsp);
            return BitConverter.ToString(byteCsp);
        }
    }


    public class GameRule
    {
        private Subject Subject { get; set; }

        public GameRule(Subject subject)
        {
            Subject = subject;
        }
        /// <summary>
        /// 撕名牌
        /// </summary>
        /// <param name="ob1"></param>
        /// <param name="ob2"></param>
        /// <returns></returns>
        public Observer RipTheNameplate(Observer ob1, Observer ob2)
        {
            Random rand1=new Random(1);
            Random rand2=new Random(5);
            int num1 = rand1.Next(1,1000);
            int num2 = rand2.Next(1, 1000);
            if (num1>num2)
            {
                Subject.NotifyObservers(ob1.Name+"Out");
                return ob1;
            }
            else
            {
                Subject.NotifyObservers(ob2.Name + "Out");
                return ob2;
            }
        }
    }


    public static class Client
    {
        public static void Run()
        {
            Subject sub = new Subject();

            Observer Observer1 = new Observer("邓超");
            Observer Observer2 = new Observer("郑凯");
            Observer Observer3 = new Observer("Baby");
            Observer Observer4 = new Observer("包贝尔");
            Observer Observer5 = new Observer("陈赫");
            Observer Observer6 = new Observer("李晨");


            sub.Attach(Observer1);
            sub.Attach(Observer2);
            sub.Attach(Observer3);
            sub.Attach(Observer4);
            sub.Attach(Observer5);
            sub.Attach(Observer6);
            //让邓超和郑凯撕名牌
            new GameRule(sub).RipTheNameplate(Observer1, Observer2);
           
            Console.Read();
        }
    }
}

 

目标和观察者之间的关系

     按照模式的定义，目标和观察者之间是典型的1对多的关系，但是注意，如果观察者只有一个，也可以是1对1的 关系，这也使得在处理一个对象的状态变化会影响到另一个对象的时候，也可以考虑使用观察者模式。

同样的，一个观察者也可以观察多个目标，如果观察者为多个目标定义的通知更新方法都是Update方法的话，这会带来麻烦，因为需要接受多个目标的通知，如果是一个Update方法，那就需要在方法内部区分，到底这个更新的通知来自于哪一个目标，不同的目标有不同的后续操作。

  一般情况下，观察者应该是不同的观察者目标定义不同的回调方法，这样实现最简单，不需要在update方法内部进行区分。

   单向依赖，在观察者模式中，观察者和目标是单向依赖的，只有观察者依赖于目标，而目标是不依赖于观察者的。

他们之间的主动权掌握在目标手里，只有目标知道什么时候需要通知观察者，在整个过程中，观察者始终是被动的。被动的等待目标的通知。等待目标传值给它。

对目标而言，所有的观察者都是一样的，目标会一视同仁的对待。当然也可以通过在目标中进行控制，实现有区别的对待观察者。比如某些状态变化了，只需要通知部分观察者。但那是属于稍微变形的用法了。不属于标准的，原始的观察者模式。

基本的实现说明：

1，具体的目标实现对象要能维护观察者的注册信息，最简单的实现方案就如同前面的例子那样，采用一个集合来保存观察者的注册信息。

2，具体的目标实现对象需要维护引起通知的状态，一般情况下目标自身的变形使用的情况下，也可以是别的对象的状态。

3，具体的观察者实现对象需要能接受目标的通知，能够接受目标传递的数据，或者是能够主动去获取目标的数据，并进行后续处理

4，如果是一个观察者目标观察多个目标，那么在观察者的更新方法里，需要去判断是来自哪一个目标的通知。一种简单的解决方案就是扩展Update方法，比如在方法里面多传递一个参数进行区分等；还有一个更简单的方法，那就是干脆定义不同的回调方法。

命名建议

1,观察者模式又被称为 发布--订阅模式

2，目标接口的定义，建议在名称后面跟Subject

3，观察者接口的定义，建议在名称后面跟observer

观察者接口的更新方法，，建议名称为Update，当然方法的参数可以根据情况而定，参数个数，类型不限。

触发通知的时机：

  在实现观察者模式的时候，一定要注意触发通知的时机，一般情况下，是在完成了状态维护后触发，因为通知会传递数据，不能够先通知后改数据，这很容易出问题，会导致观察者和目标对象的状态不一致。

比如，目标一触发通知，就有观察者来取值，结果目标还没有更新数据，这就明显地造成了错误。

观察者模式的两种模式：

推模式：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的信息通常是目标对象的全部或部分数据，相当于是在广播通信

拉模式：目标对象在通知观察者的时候，只传少量信息。如果观察者需要更具体的信息。有观察者主动到目标对象中取，相当于是观察者从目标对象中拉数据。一般这种模式的实现中，会把目标对象自身通过update方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。

推模式是假定目标对象知道观察者需要的数据，而拉模式是目标对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传给观察者，让观察者自己去按需求取值。

推模式可能会使得观察者对象难以复用，因为观察者定义的update方法是按需而定义的，可能无法兼顾没有考虑到的情况。这就意味着出现新情况的时候，就可能需要提供新的update方法，或者干脆重新实现观察者。而拉模式就不会造成这样的情况，因为拉模式下，update方法的参数就是目标对象本身，这基本上是目标对象能传递的最大数据集合了，基本上可以适应各种情况的需求。