1. 概述

　　有時被稱作釋出/訂閱模式，觀察者模式定義了一種一對多的依賴關係，讓多個觀察者物件同時監聽某一個主題物件。這個主題物件在狀態發生變化時，會通知所有觀察者物件，使它們能夠自動更新自己。

2. 解決的問題

　　將一個系統分割成一個一些類相互協作的類有一個不好的副作用，那就是需要維護相關物件間的一致性。我們不希望為了維持一致性而使各類緊密耦合，這樣會給維護、擴充套件和重用都帶來不便。觀察者就是解決這類的耦合關係的。

3. 模式中的角色

　　3.1 抽象主題（Subject）：它把所有觀察者物件的引用儲存到一個聚集裡，每個主題都可以有任何數量的觀察者。抽象主題提供一個介面，可以增加和刪除觀察者物件。

　　3.2 具體主題（ConcreteSubject）：將有關狀態存入具體觀察者物件；在具體主題內部狀態改變時，給所有登記過的觀察者發出通知。

　　3.3 抽象觀察者（Observer）：為所有的具體觀察者定義一個介面，在得到主題通知時更新自己。

　　3.4 具體觀察者（ConcreteObserver）：實現抽象觀察者角色所要求的更新介面，以便使本身的狀態與主題狀態協調。

4. 模式解讀

　　4.1 觀察者模式的類圖　　

　　4.2 觀察者模式的程式碼

    /// <summary>
    /// 抽象主題類
    /// </summary>
    public abstract
 
 class Subject
    {
        private IList<Observer> observers = new List<Observer>();

        /// <summary>
        /// 增加觀察者
        /// </summary>
        /// <param name="observer"></param>
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        
 
/// <summary>
        /// 移除觀察者
        /// </summary>
        /// <param name="observer"></param>
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        /// <summary>
        /// 向觀察者（們）發出通知
        /// </summary>
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }

    /// <summary>
    /// 抽象觀察者類，為所有具體觀察者定義一個介面，在得到通知時更新自己
    /// </summary>
    public abstract class Observer
    {
        public abstract void Update();
    }

    /// <summary>
    /// 具體觀察者或具體通知者，將有關狀態存入具體觀察者物件；在具體主題的內部狀態改變時，給所有登記過的觀察者發出通知。具體主題角色通常用一個具體子類實現。
    /// </summary>
    public class ConcreteSubject : Subject
    {
        private string subjectState;

        /// <summary>
        /// 具體觀察者的狀態
        /// </summary>
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }

    /// <summary>
    /// 具體觀察者，實現抽象觀察者角色所要求的更新介面，已是本身狀態與主題狀態相協調
    /// </summary>
    public class ConcreteObserver : Observer
    {
        private string observerState;
        private string name;
        private ConcreteSubject subject;

        /// <summary>
        /// 具體觀察者用一個具體主題來實現
        /// </summary>
        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }

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

        /// <summary>
        /// 實現抽象觀察者中的更新操作
        /// </summary>
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("The observer's state of {0} is {1}", name, observerState);
        }
    }

　　4.3 客戶端程式碼

    class Program
    {
        static void Main(string[] args)
        {
            // 具體主題角色通常用具體自來來實現
            ConcreteSubject subject = new ConcreteSubject();

            subject.Attach(new ConcreteObserver(subject, "Observer A"));
            subject.Attach(new ConcreteObserver(subject, "Observer B"));
            subject.Attach(new ConcreteObserver(subject, "Observer C"));

            subject.SubjectState = "Ready";
            subject.Notify();

            Console.Read();
        }
    }

　　執行結果

5. 模式總結

　　5.1 優點

　　　　5.1.1 觀察者模式解除了主題和具體觀察者的耦合，讓耦合的雙方都依賴於抽象，而不是依賴具體。從而使得各自的變化都不會影響另一邊的變化。

　　5.2 缺點

　　　　5.2.1 依賴關係並未完全解除，抽象通知者依舊依賴抽象的觀察者。

　　5.3 適用場景

　　　　5.3.1 當一個物件的改變需要給變其它物件時，而且它不知道具體有多少個物件有待改變時。

　　　　5.3.2 一個抽象某型有兩個方面，當其中一個方面依賴於另一個方面，這時用觀察者模式可以將這兩者封裝在獨立的物件中使它們各自獨立地改變和複用。

6. 模式引申，應用C#中的事件委託來徹底解除通知者和觀察者之間的耦合。

　　　6.1 關於委託的定義：委託是一種引用方法的型別。一旦為委託分配了方法，委託將與該方法有相同的行為。委託方法可以像其它任何方法一樣，具有引數和返回值。委託可以看作是對函式（方法）的的抽象，是函式的“類”，委託的例項代表一個（或多個）具體的函式，它可以是多播的。

　　　6.2 關於事件：事件基於委託，為委託提供了一種釋出/訂閱機制。事件的訂閱與取消與我們剛才講的觀察者模式中的訂閱與取消類似，只是表現形式有所不同。在觀察者模式中，訂閱使用方法Attach（）來進行；在事件的訂閱中使用“+=”。類似地，取消訂閱在觀察者模式中用Dettach（），而事件的取消用“-=”。

7. 下面例子分別用觀察者模式，事件機制來實現

　　7.1 例項描述：客戶支付了訂單款項，這時財務需要開具發票，出納需要記賬，配送員需要配貨。

　　7.2 觀察者模式的實現

　　　　7.2.1 類圖

　　　　7.2.2 程式碼實現

    /// <summary>
    /// 抽象觀察者
    /// </summary>
    public interface ISubject
    {
        void Notify();
    }

    /// <summary>
    /// 工作崗位，作為這裡的觀察者的抽象
    /// </summary>
    public abstract class JobStation
    {
        public abstract void Update();
    }

    /// <summary>
    /// 具體主題，這裡是客戶
    /// </summary>
    public class Customer : ISubject
    {
        private string customerState;

        private IList<JobStation> observers = new List<JobStation>();

        /// <summary>
        /// 增加觀察者
        /// </summary>
        /// <param name="observer"></param>
        public void Attach(JobStation observer)
        {
            this.observers.Add(observer);
        }

        /// <summary>
        /// 移除觀察者
        /// </summary>
        /// <param name="observer"></param>
        public void Detach(JobStation observer)
        {
            this.observers.Remove(observer);
        }

        /// <summary>
        /// 客戶狀態
        /// </summary>
        public string CustomerState
        {
            get { return customerState; }
            set { customerState = value; }
        }

        public void Notify()
        {
            foreach (JobStation o in observers)
            {
                o.Update();
            }
        }
    }

    /// <summary>
    /// 會計
    /// </summary>
    public class Accountant : JobStation
    {
        private string accountantState;
        private Customer customer;

        public Accountant(Customer customer)
        {
            this.customer = customer;
        }

        /// <summary>
        /// 更新狀態
        /// </summary>
        public override void Update()
        {
            if (customer.CustomerState == "已付款")
            {
                Console.WriteLine("我是會計，我來開具發票。");
                accountantState = "已開發票";
            }
        }
    }

    /// <summary>
    /// 出納
    /// </summary>
    public class Cashier : JobStation
    {
        private string cashierState;
        private Customer customer;

        public Cashier(Customer customer)
        {
            this.customer = customer;
        }

        public override void Update()
        {
            if (customer.CustomerState == "已付款")
            {
                Console.WriteLine("我是出納員，我給登記入賬。");
                cashierState = "已入賬";
            }
        }
    }

    /// <summary>
    /// 配送員
    /// </summary>
    public class Dilliveryman : JobStation
    {
        private string dillivierymanState;
        private Customer customer;

        public Dilliveryman(Customer customer)
        {
            this.customer = customer;
        }

        public override void Update()
        {
            if (customer.CustomerState == "已付款")
            {
                Console.WriteLine("我是配送員，我來發貨。");
                dillivierymanState = "已發貨";
            }
        }
    }

　　　　7.2.3 客戶端程式碼

    class Program
    {
        static void Main(string[] args)
        {

            Customer subject = new Customer();

            subject.Attach(new Accountant(subject));
            subject.Attach(new Cashier(subject));
            subject.Attach(new Dilliveryman(subject));

            subject.CustomerState = "已付款";
            subject.Notify();

            Console.Read();
        }
    }

　　　　執行結果：

　　　　我是會計，我來開具發票。
　　　　我是出納員，我給登記入賬。
　　　　我是配送員，我來發貨。

　　7.3 事件實現

　　　　7.3.1 類圖

　　　　通過類圖來看，觀察者和主題之間已經不存在任何依賴關係了。

　　　　7.3.2 程式碼實現

    /// <summary>
    /// 抽象主題
    /// </summary>
    public interface ISubject
    {
        void Notify();
    }

    /// <summary>
    /// 宣告委託
    /// </summary>
    public delegate void CustomerEventHandler();

    /// <summary>
    /// 具體主題
    /// </summary>
    public class Customer : ISubject
    {
        private string customerState;

        // 宣告一個委託事件，型別為 CustomerEventHandler
        public event CustomerEventHandler Update;

        public void Notify()
        {
            if (Update != null)
            {
                // 使用事件來通知給訂閱者
                Update();
            }
        }

        public string CustomerState
        {
            get { return customerState; }
            set { customerState = value; }
        }
    }

    /// <summary>
    /// 財務，已經不需要實現抽象的觀察者類，並且不用引用具體的主題
    /// </summary>
    public class Accountant
    {
        private string accountantState;

        public Accountant()
        { }

        /// <summary>
        /// 開發票
        /// </summary>
        public void GiveInvoice()
        {
            Console.WriteLine("我是會計，我來開具發票。");
            accountantState = "已開發票";
        }
    }

    /// <summary>
    /// 出納，已經不需要實現抽象的觀察者類，並且不用引用具體的主題
    /// </summary>
    public class Cashier
    {
        private string cashierState;

        public void Recoded()
        {
            Console.WriteLine("我是出納員，我給登記入賬。");
            cashierState = "已入賬";
        }
    }

    /// <summary>
    /// 配送員，已經不需要實現抽象的觀察者類，並且不用引用具體的主題
    /// </summary>
    public class Dilliveryman
    {
        private string dillivierymanState;

        public void Dilliver()
        {
            Console.WriteLine("我是配送員，我來發貨。");
            dillivierymanState = "已發貨";
        }
    }

　　　　7.3.3 客戶端程式碼

    class Program
    {
        static void Main(string[] args)
        {

            Customer subject = new Customer();

            Accountant accountant = new Accountant();
            Cashier cashier = new Cashier();
            Dilliveryman dilliveryman = new Dilliveryman();

            // 註冊事件
            subject.Update += accountant.GiveInvoice;
            subject.Update += cashier.Recoded;
            subject.Update += dilliveryman.Dilliver;

            /*
             * 以上寫法也可以用下面程式碼來替換
            subject.Update += new CustomerEventHandler(accountant.GiveInvoice);
            subject.Update += new CustomerEventHandler(cashier.Recoded);
            subject.Update += new CustomerEventHandler(dilliveryman.Dilliver);
             */

            subject.CustomerState = "已付款";
            subject.Notify();

            Console.Read();
        }
    }