设计模式：观察者模式（Observer Pattern） 明

作者：TerryLee  创建于：2006-07-17 出处：http://www.cnblogs.com/Terrylee/archive/2006/10/23/Observer_Pattern.html 收录于：2006-10-23  收录于：2013-03-01

结构图

---

意图

---

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

适用性

---

• 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
• 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。 

实现代码

---

下面通过一个例子来说明Observer模式。监控某一个公司的股票价格变化，可以有多种方式，通知的对象可以是投资者，或者是发送到移动设备，还有电子邮件等。一开始我们先不考虑Observer模式，通过一步步地重构，最终重构为Observer模式。现在有这样两个类：Microsoft和Investor，如下图所示：

using System;
    public class Microsoft
    {
        private Investor _investor;
        private String _symbol;
        private double _price;
        public void Update()
        {
            _investor.SendData(this);
        }
        public Investor Investor
        {
            get { return _investor; }
            set { _investor = value; }
        }
        public String Symbol
        {
            get { return _symbol; }
            set { _symbol = value; }
        }
        public double Price
        {
            get { return _price; }
            set { _price = value; }
        }
    }
    public class Investor
    {
        private string _name;
        public Investor(string name)
        {
            this._name = name;
        }
        public void SendData(Microsoft ms)
        {
            Console.WriteLine("Notified {0}： Company '{1}' " + "change to {2:C}", _name, ms.Symbol, ms.Price);
        }
    }
    //客户端代码
    class Program
    {
        static void Main(string[] args)
        {
            Investor investor = new Investor("Jom");
            Microsoft ms = new Microsoft();
            ms.Investor = investor;
            ms.Symbol = "Microsoft";
            ms.Price = 120.00;
            ms.Update();
            Console.ReadLine();
        }
    }

可以看到，这段代码运行并没有问题，也确实实现了我们最初的设想的功能，把Microsoft的股票价格变化通知到了Jom投资者那儿。但是这里面出现了如下几个问题：

（1）Microsoft和Investor之间形成了一种双向的依赖关系，即Microsoft调用了Investor的方法，而Investor调用了Microsoft类的属性。如果有其中一个类变化，有可能会引起另一个的变化。
（2）当出现一种的通知对象，比如说是移动设备Mobile：

既然出现了多个通知对象，我们就为这些对象之间抽象出一个接口，用它来取消Microsoft和具体的通知对象之间依赖。

 

    using System;
    using System.Collections.Generic;

    public interface IObserver
    {
        void SendData(Microsoft ms);
    }
    public class Investor : IObserver
    {
        private string _name;
        public Investor(string name)
        {
            this._name = name;
        }

        public void SendData(Microsoft ms)
        {
            Console.WriteLine("Notified {0}： Company '{1}' " + "change to {2:C}", _name, ms.Symbol, ms.Price);
        }
    }

    public class Microsoft
    {
        private List<IObserver> observers = new List<IObserver>();
        private String _symbol;
        private double _price;
        public String Symbol
        {
            get { return _symbol; }
            set { _symbol = value; }
        }
        public double Price
        {
            get { return _price; }
            set { _price = value; }
        }

        public void Update()
        {
            foreach (IObserver ob in observers)
            {
                ob.SendData(this);
            }
        }

        public void AddObserver(IObserver observer)
        {
            observers.Add(observer);
        }
        public void RemoveObserver(IObserver observer)
        {
            observers.Remove(observer);
        }        
    }

    //客户端代码
    class Program
    {
        static void Main(string[] args)
        {
            IObserver investor1 = new Investor("Jom");
            IObserver investor2 = new Investor("TerryLee");
            Microsoft ms = new Microsoft();
            ms.Symbol = "Microsoft";
            ms.Price = 120.00;
            ms.AddObserver(investor1);
            ms.AddObserver(investor2);
            ms.Update();
            Console.ReadLine();
        }
    }

走到这一步，已经有了Observer模式的影子了，Microsoft类不再依赖于具体的Investor，而是依赖于抽象的IOberver。存在着的一个问题是Investor仍然依赖于具体的公司Microsoft，况且公司还会有很多IBM，Google等，解决这样的问题很简单，只需要再对Microsoft类做一次抽象。如下图所示：

namespace Program
{
    using System;
    using System.Collections.Generic;
    public interface IObserver
    {
        void SendData(Stock ms);
    }
    public class Investor : IObserver
    {
        private string _name;
        public Investor(string name)
        {
            this._name = name;
        }
        public void SendData(Stock ms)
        {
            Console.WriteLine("Notified {0}： Company '{1}' " + "change to {2:C}", _name, ms.Symbol, ms.Price);
        }
    }
    public abstract class Stock
    {
        private List<IObserver> observers = new List<IObserver>();
        private String _symbol;
        private double _price;
        public Stock(String symbol, double price)
        {
            this._symbol = symbol;
            this._price = price;
        }
        public void Update()
        {
            foreach (IObserver ob in observers)
            {
                ob.SendData(this);
            }
        }
        public void AddObserver(IObserver observer)
        {
            observers.Add(observer);
        }
        public void RemoveObserver(IObserver observer)
        {
            observers.Remove(observer);
        }
        public String Symbol
        {
            get { return _symbol; }
        }
        public double Price
        {
            get { return _price; }
        }
    }
    public class Microsoft : Stock
    {
        public Microsoft(String symbol, double price)
            : base(symbol, price)
        { }
    }
    //客户端代码
    class Program
    {
        static void Main(string[] args)
        {
            Stock ms = new Microsoft("Microsoft", 120.00);
            ms.AddObserver(new Investor("Jom"));
            ms.AddObserver(new Investor("TerryLee"));
            ms.Update();
            Console.ReadLine();
        }
    }
}

到这里我们可以看到，通过不断的重构，不断地抽象，我们由一开始的很糟糕的设计，逐渐重构为使用Observer模式的这样一个方案。在这个例子里面，IOberser充当了观察者的角色，而Stock则扮演了主题对象角色，在任何时候，只要调用了Stock的Update()方法，它就会通知它的所有观察者对象。同时可以看到，通过Observer模式，取消了直接依赖，变为间接依赖，这样大大提供了系统的可维护性和可扩展性。

.NET中的Observer模式

---

在.NET中，相信大家对于事件和委托都已经不陌生了，这里就不具体多说了。利用事件和委托来实现Observer模式我认为更加的简单和优雅，也是一种更好的解决方案。因为在上面的示例中我们可以看到，虽然取消了直接耦合，但是又引入了不必要的约束（暂且这么说吧）。即那些子类必须都继承于主题父类，还有观察者接口等。网上有很多这方面的例子，上面的例子简单的用事件和委托实现如下，仅供大家参考：

using System;
    using System.Collections.Generic;
    class Program
    {
        static void Main(string[] args)
        {
            Stock stock = new Stock("Microsoft", 120.00);
            Investor investor = new Investor("Jom");
            stock.NotifyEvent += new NotifyEventHandler(investor.SendData);
            stock.Update();
            Console.ReadLine();
        }
    }
    public delegate void NotifyEventHandler(object sender);
    public class Stock
    {
        public NotifyEventHandler NotifyEvent;
        private String _symbol;
        private double _price;
        public Stock(String symbol, double price)
        {
            this._symbol = symbol;
            this._price = price;
        }
        public void Update()
        {
            OnNotifyChange();
        }
        public void OnNotifyChange()
        {
            if (NotifyEvent != null)
            {
                NotifyEvent(this);
            }
        }
        public String Symbol
        {
            get { return _symbol; }
        }
        public double Price
        {
            get { return _price; }
        }
    }
    public class Investor
    {
        private string _name;
        public Investor(string name)
        {
            this._name = name;
        }
        public void SendData(object obj)
        {
            if (obj is Stock)
            {
                Stock stock = (Stock)obj;
                Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, stock.Symbol, stock.Price);
            }
        }
    }

效果及实现要点

---

1．使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。

2．目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。

3．在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。