观察者模式是一种平时接触较多的模式。它主要用于一对多的通知发布机制，当一个对象发生改变时自动通知其他对象，其他对象便做出相应的反应，同时保证了被观察对象与观察对象之间没有直接的依赖。
GOF对观察者模式的描述为：
Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically..
— Design Patterns : Elements of Reusable Object-Oriented Software
观察者模式的适用场景
- 当存在一类对象通知关系上依赖于另一类对象的时候，把它们进行抽象，确保两类对象的具体实现都可以相对独立的变化，但它们交互的接口保持稳定。
- 一个类型状态变化时，需要通知的对象的数量不固定，会有增加或删除若干被通知对象的情况。
- 需要让目标对象与被通知对象之间保持松散耦合的时间。
UML类图如下：
代码实例
public interface IObserver<T>
{
void Update(SubjectBase<T> subject);
}
public abstract class SubjectBase<T>
{
protected IList<IObserver<T>> observers = new List<IObserver<T>>();
protected T state;
public virtual T State
{
get { return state; }
}
//Attach
public static SubjectBase<T> operator +(SubjectBase<T> subject, IObserver<T> observer)
{
subject.observers.Add(observer);
return subject;
}
//Detach
public static SubjectBase<T> operator -(SubjectBase<T> subject, IObserver<T> observer)
{
subject.observers.Remove(observer);
return subject;
}
//更新各观察者
public virtual void Notify()
{
foreach (var observer in observers)
{
observer.Update(this);
}
}
public virtual void Update(T state)
{
this.state = state;
Notify();//触发对外通知
}
}
public class Subject<T> : SubjectBase<T> { }
public class Observer<T> : IObserver<T>
{
public T State;
public void Update(SubjectBase<T> subject)
{
this.State = subject.State;
}
}
调用端
static void Main(string[] args)
{
SubjectBase<int> subject = new Subject<int>();
Observer<int> observer1 = new Observer<int>();
observer1.State = 10;
Observer<int> observer2 = new Observer<int>();
observer2.State = 20;
subject += observer1;
subject += observer2;
subject.Update(30);
Console.WriteLine($"ob1:{observer1.State} ob2:{observer2.State}");
//ob1:30 ob2:30 两个观察者都发生了变化
subject -= observer2;
subject.Update(40);
Console.WriteLine($"ob1:{observer1.State} ob2:{observer2.State}");
//ob1:40 ob2:30 observer2被移除，不会跟随变化
}
这里的被观察者继承基类SubjectBase，观察者实现接口IObserver。SubjectBase和IObserver相互依赖，SubjectBase本身不知道会有哪些具体IObserver类型希望获得它的更新通知，具体的Observer类型也并不需要关心目标类型，只需要依赖SubjectcBase，所以实际上一个观察者可以跟踪多个被观察者。
推模式和拉模式
根据当目标对象状态更新的时候，观察者更新自己数据的方式，可以将观察者模式分为推模式和拉模式。
推模式：目标对象在通知里把需要更新的信息作为参数提供给IObserver的Update()方法。采用这种方式，观察者只能只能被动接受，如果推送的内容比较多，那么对网络、内存或者I/O的开销就会很大。
拉模式：目标对象仅仅告诉观察者有新的状态，至于该状态是什么，则需要观察者主动访问目标对象来获取。这种方式下，观察者获取信息的时机和内容都可以自主决定，但如果观察者没有及时获取信息，就会漏掉之前通知的内容。
前面的代码示例是两种方式的结合，看起来像是推模式，但他推送的是一个SubjectBase的引用，观察者可以根据需要通过这个引用访问到具体的状态，从这个角度看又是拉模式。
事件
.NET中的事件机制也可以看作观察者模式，事件所定义的委托类型本身就是个抽象的观察者，而且相对经典的观察者模式，事件更加简单、灵活，耦合也更加松散。
代码示例
public class UserEventArgs : EventArgs
{
public string Name { get; }
public UserEventArgs(string name)
{
this.Name = name;
}
}
public class User
{
public event EventHandler<UserEventArgs> NameChanged;
private string name;
public string Name
{
get { return name; }
set
{
name = value;
NameChanged(this, new UserEventArgs(value));
}
}
}
观察者，注册事件
public class Test
{
public static void Entry()
{
User user = new User();
user.NameChanged += (sender, args) =>
{
Console.WriteLine(args.Name);
};
user.Name = "Andy";
}
}
观察者模式的缺点
- 如果观察者比较多，逐个通知会相对耗时。
- 测试和调试相比直接依赖更加困难。
- 可能导致内存泄漏，即使所有观察者都已经失效了，但如果它们没有注销对主题对象的观察，那么观察者和主题对象间的这种相互的引用关系，会使双方无法被GC回收。
参考书籍：
王翔著 《设计模式——基于C#的工程化实现及扩展》
