C#设计模式之Observer设计模式(观察者设计模式)

C#设计模式之Observer设计模式(观察者设计模式)

一、观察者（Observer）模式

观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

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

一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作（Collaboration）。观察者模式是满足这一要求的各种设计方案中最重要的一种。

二、观察者模式的结构

观察者模式的类图如下：

可以看出，在这个观察者模式的实现里有下面这些角色：

抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。

抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。

具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。

具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。

三、观察者模式的示意性源代码

// Observer pattern -- Structural example　
using System;
using System.Collections;
// "Subject"
abstract class Subject
{
　// Fields
　private ArrayList observers = new ArrayList();
　// Methods
　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();
　}
}
// "ConcreteSubject"
class ConcreteSubject : Subject
{
　// Fields
　private string subjectState;
　// Properties
　public string SubjectState
　{
　　get{ return subjectState; }
　　set{ subjectState = value; }
　}
}
// "Observer"
abstract class Observer
{
　// Methods
　abstract public void Update();
}
// "ConcreteObserver"
class ConcreteObserver : Observer
{
　// Fields
　private string name;
　private string observerState;
　private ConcreteSubject subject;
　// Constructors
　public ConcreteObserver( ConcreteSubject subject,　
　　string name )
　{
　　this.subject = subject;
　　this.name = name;
　}
　// Methods
　override public void Update()
　{
　　observerState = subject.SubjectState;
　　Console.WriteLine( "Observer {0}'s new state is {1}",
　　　name, observerState );
　}
　// Properties
　public ConcreteSubject Subject
　{
　　get { return subject; }
　　set { subject = value; }
　}
}
/** <summary>
/// Client test
/// </summary>
public class Client
{
　public static void Main( string[] args )
　{
　　// Configure Observer structure
　　ConcreteSubject s = new ConcreteSubject();
　　s.Attach( new ConcreteObserver( s, "1" ) );
　　s.Attach( new ConcreteObserver( s, "2" ) );
　　s.Attach( new ConcreteObserver( s, "3" ) );
　　// Change subject and notify observers
　　s.SubjectState = "ABC";
　　s.Notify();
　}
}

四、C#中的Delegate与Event

实际上在C#中实现Observer模式没有这么辛苦，.NET中提供了Delegate与Event机制，我们可以利用这种机制简化Observer模式。关于Delegate与Event的使用方法请参考相关文档。改进后的Observer模式实现如下：

// Observer pattern -- Structural example　
using System;
//Delegate
delegate void UpdateDelegate();
//Subject
class Subject
{
　public event UpdateDelegate UpdateHandler;
　// Methods
　public void Attach( UpdateDelegate ud )
　{
　　UpdateHandler += ud;
　}
　public void Detach( UpdateDelegate ud )
　{
　　UpdateHandler -= ud;
　}
　public void Notify()
　{
　　if(UpdateHandler != null) UpdateHandler();
　}
}
//ConcreteSubject
class ConcreteSubject : Subject
{
　// Fields
　private string subjectState;
　// Properties
　public string SubjectState
　{
　　get{ return subjectState; }
　　set{ subjectState = value; }
　}
}
// "ConcreteObserver"
class ConcreteObserver
{
　// Fields
　private string name;
　private string observerState;
　private ConcreteSubject subject;
　// Constructors
　public ConcreteObserver( ConcreteSubject subject,　
　　string name )
　{
　　this.subject = subject;
　　this.name = name;
　}
　// Methods
　public void Update()
　{
　　observerState = subject.SubjectState;
　　Console.WriteLine( "Observer {0}'s new state is {1}",
　　　name, observerState );
　}
　// Properties
　public ConcreteSubject Subject
　{
　　get { return subject; }
　　set { subject = value; }
　}
}
// "ConcreteObserver"
class AnotherObserver
{
　// Methods
　public void Show()
　{
　　Console.WriteLine("AnotherObserver got an Notification!");
　}
}
public class Client
{
　public static void Main(string[] args)
　{
　　ConcreteSubject s = new ConcreteSubject();
　　ConcreteObserver o1 = new ConcreteObserver(s, "1");
　　ConcreteObserver o2 = new ConcreteObserver(s, "2");
　　AnotherObserver o3 = new AnotherObserver();
　　s.Attach(new UpdateDelegate(o1.Update));
　　s.Attach(new UpdateDelegate(o2.Update));
　　s.Attach(new UpdateDelegate(o3.Show));
　　s.SubjectState = "ABC";
　　s.Notify();
　　Console.WriteLine("--------------------------");
　　s.Detach(new UpdateDelegate(o1.Update));
　　s.SubjectState = "DEF";
　　s.Notify();
　}
}

其中，关键的代码如下：

delegate void UpdateDelegate();

定义一个Delegate，用来规范函数结构。不管是ConcreteObserver类的Update方法还是AnotherObserver类的Show方法都符合该Delegate。这不象用Observer接口来规范必须使用Update方法那么严格。只要符合Delegate所指定的方法结构的方法都可以在后面被事件所处理。

public event UpdateDelegate UpdateHandler;

定义一个事件，一旦触发，可以调用一组符合UpdateDelegate规范的方法。

　public void Attach( UpdateDelegate ud )
　{
　　UpdateHandler += ud;
　}

订阅事件。只要是一个满足UpdateDelegate的方法，就可以进行订阅操作（如下所示）。

　　s.Attach(new UpdateDelegate(o1.Update));
　　s.Attach(new UpdateDelegate(o2.Update));
　　s.Attach(new UpdateDelegate(o3.Show));

在Notify方法中：

　public void Notify()
　{
　　if(UpdateHandler != null) UpdateHandler();
　}

只要UpdateHandler != null（表示有订阅者），就可以触发事件（UpdateHandler()），所有的订阅者便会接到通知。

五、一个实际应用观察者模式的例子

该例子演示了注册的投资者在股票市场发生变化时，可以自动得到通知。该例子仍然使用的是传统的Observer处理手段，至于如何转换成Delegate与Event留给读者自己考虑。

// Observer pattern -- Real World example　
using System;
using System.Collections;
// "Subject"
abstract class Stock
{
　// Fields
　protected string symbol;
　protected double price;
　private ArrayList investors = new ArrayList();
　// Constructor
　public Stock( string symbol, double price )
　{
　　this.symbol = symbol;
　　this.price = price;
　}
　// Methods
　public void Attach( Investor investor )
　{
　　investors.Add( investor );
　}
　public void Detach( Investor investor )
　{
　　investors.Remove( investor );
　}
　public void Notify()
　{
　　foreach( Investor i in investors )
　　　i.Update( this );
　}
　// Properties
　public double Price
　{
　　get{ return price; }
　　set
　　{
　　　price = value;
　　　Notify();
　　}
　}
　public string Symbol
　{
　　get{ return symbol; }
　　set{ symbol = value; }
　}
}
// "ConcreteSubject"
class IBM : Stock
{
　// Constructor
　public IBM( string symbol, double price )
　　: base( symbol, price ) {}
}
// "Observer"
interface IInvestor
{
　// Methods
　void Update( Stock stock );
}
// "ConcreteObserver"
class Investor : IInvestor
{
　// Fields
　private string name;
　private string observerState;
　private Stock stock;
　// Constructors
　public Investor( string name )
　{
　　this.name = name;
　}
　// Methods
　public void Update( Stock stock )
　{
　　Console.WriteLine( "Notified investor {0} of {1}'s change to {2:C}",
　　　name, stock.Symbol, stock.Price );
　}
　// Properties
　public Stock Stock
　{
　　get{ return stock; }
　　set{ stock = value; }
　}
}
/** <summary>
/// ObserverApp test
/// </summary>
public class ObserverApp
{
　public static void Main( string[] args )
　{
　　// Create investors
　　Investor s = new Investor( "Sorros" );
　　Investor b = new Investor( "Berkshire" );
　　// Create IBM stock and attach investors
　　IBM ibm = new IBM( "IBM", 120.00 );
　　ibm.Attach( s );
　　ibm.Attach( b );
　　// Change price, which notifies investors
　　ibm.Price = 120.10;
　　ibm.Price = 121.00;
　　ibm.Price = 120.50;
　　ibm.Price = 120.75;
　}
}

六、观察者模式的优缺点

Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。

但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。

观察者模式的效果有以下几个优点：

（1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

（2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。

观察者模式有下面的一些缺点：

（1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

（2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。

（3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

（4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

 

 

来自于： http://www.bianceng.cn/Programming/csharp/201012/22212.htm