观察者模式

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

using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;

public class ObserverModel : MonoBehaviour {

    private ConcreteSubject s;
    // Use this for initialization
    void Start () {
        s = new ConcreteSubject();
    }
    
    // Update is called once per frame
    void Update () {
    
    }

    void OnGUI()
    {
        if(GUI.Button(new Rect(0,0,100,50),""))
        {
            Function();
        }
    }
    /// <summary>
    /// 客户端的调用//
    /// </summary>
    void Function()
    {
        s.Attach(new ConcreteObserver(s,"X"));
        s.Attach(new ConcreteObserver(s,"Y"));
        s.Attach(new ConcreteObserver(s,"Z"));

        s.SubjectState = "ABC";
        s.Notify();
    }
}

/*
 * 抽象主题类：
 *          它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任意数量的观察者。
 *          抽象主题提供一个接口，可以增加和删除观察者对象。
 */
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();
        }
    }
}

/**
 *  // 抽象观察者类, 
 *          为所有的具体观察者定义一个接口，得到主题更新时通知自己。这个接口叫做更新接口。
 *          抽象观察者一般由一个抽象类，或者抽象接口实现。更新通常包含一个Update方法。
 */
abstract class Observer 
{
    public abstract void Update();
}

/*
 * 具体主题类：
 *          将有关状态存入具体的观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发送通知。
 *          具体主题类角色一般由一个具体子类实现。
 * */
class ConcreteSubject : Subject 
{
    private string subjectState;

    ///具体被观察者状态
    public string SubjectState 
    {
        get { return subjectState; }
        set { subjectState = value; }
    }
}

/*
 * 具体观察者类：
 *          实现抽象观察者角色所要求的更新接口，以便本身的状态和主体状态相协调。
 *          具体观察者可以保存一个指向具体主题的引用。具体观察者角色通常用一个具体子类实现。
 * */
class ConcreteObserver : Observer 
{
    private string name;
    private string observerState;
    private ConcreteSubject subject;

    public ConcreteObserver(ConcreteSubject subject,string name)
    {
        this.subject = subject;
        this.name = name;
    }

    public override void Update()
    {
        //throw new NotImplementedException();
        observerState = subject.SubjectState;
        Debug.Log("Observer :" + name + " new state is "+ observerState.ToString());
    }

    public ConcreteSubject Subject 
    {
        get { return subject; }
        set { subject = value; }
    }
}

/*
 *          何时使用？
 *          当一个对象的改变需要同时改变其他的对象，而且不知道具体有多少对象有待改变的时候，应该考虑使用观察者模式。
 *          当一个抽象模型有两个方面，其中一方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中，
 *          是他们独立的复用和改变。
 *          观察者模式所做的工作其实就是解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使各自的变化不会影响到另一边的变化。 
 *          
 */