先看下观察者模式的定义：
The Observer Pattern defines a one-to-many denpendency between objects so that when one object changes state, all of its dependents are notified and updated automatically.:观察者模式定义了对象间一对多依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
观察者模式又叫发布-订阅（Publish–Subscribe）模式，模型—视图（Model/View）模式，源—监听器（Source/Listener）模式等。
观察者模式定义了一种一对多的关系，让多个观察者同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动能够更新自己。
实现观察者模式比较直观的一种是“注册-----通知----撤销注册”的形式。
首先，观察者（Observer）将自己注册到主题对象（Subject）中，主题对象将观察者存放在一个容器（Container）中.
其次，主题对象发生了某种变化，从容器中得到所有注册过的观察者，将变化通知观察者。
最后，观察者告诉主题对象要撤销观察，主题对象从容器中将观察者去除。
观察者将自己注册到主题对象的容器中时，主题对象不应该过问观察者的具体类型，而是使用观察者的接口。这样做的优点是：假定程序中还有别的观察者，那么只要这个观察者也是相同的接口实现即可。一个主题对象可以对应多个观察者，当主题对象发生变化的时候，他可以将消息一一通知给所有的观察者。基于接口，而不是具体的实现------这一点为程序提供了更大的灵活性。
C#代码实现：
public interface IObserver
{
void Update();
}
public interface ISubject
{
void AddObserver(IObserver obs);
void RemoveObserver(IObserver obs);
void Notify();
}
public class Mouse : IObserver
{
public void Update()
{
Console.WriteLine(“Mouse is escaped”);
}
}
public class Master : IObserver
{
public void Update()
{
Console.WriteLine(“Master is waken”);
}
}
public class Cat : ISubject
{
List list = new List();
public void AddObserver(IObserver obs)
{
list.Add(obs);
}
public void RemoveObserver(IObserver obs)
{
list.Remove(obs);
}
public void Notify()
{
Console.WriteLine(“Cat is crying”);
foreach (IObserver obs in list)
{
obs.Update();
}
}
}
static void Main(string[] args)
{
IObserver mouse = new Mouse();
IObserver master = new Master();
ISubject cat = new Cat();
cat.AddObserver(mouse);
cat.AddObserver(master);
cat.Notify();
}
在.NET中，利用事件和委托来实现Observer模式更为简单，也是一中更好的解决方案。在C#的事件中，委托充当了抽象的Observer接口，而提供事件的对象充当了目标（Subject）对象。其实委托是比抽象Observer接口更为松耦合的设计，因为委托只要求挂接的方法的声明部分必须符合委托声明的格式，而不需要像接口一样必须要求类去完全实现之。观察者模式之所以叫观察者模式，并不是因为内部使用了ISubject，IObserver等来实现，而是因为这个模式解决了如下问题：“观察者模式定义了对象间的一种一对多依赖关系，使得每当一个对象改变状态，则所以依赖于它的对象都会得到通知并被自动更新”。也就是说，所有解决这个问题的方法都可以称作观察者模式。而且接口的概念也绝对不局限于C#里面的interface,接口只是一个契约，用来规范代码的行为，delegate也是一个接口，它规定了什么样的方法可以加载到delegate对应的event中，这也是一个契约，只是这个契约要比interface更简单。
下面我们用委托事件机制来实现上面的功能，代码如下：
public class Cat
{
public delegate void NotifyEventHandler();
public event NotifyEventHandler NotifyEvent;
public void Notify()
{
if (NotifyEvent != null)
{
Console.WriteLine(“Cat is crying”);
NotifyEvent();
}
}
}
public class Master
{
public void Update()
{
Console.WriteLine(“Master is waken”);
}
}
public class Mouse
{
public void Update()
{
Console.WriteLine(“Mouse is escaping”);
}
}
static void Main(string[] args)
{
Cat cat = new Cat();
Master master = new Master();
Mouse mouse = new Mouse();
Cat.NotifyEventHandler notifyMaster = new Cat.NotifyEventHandler(master.Update);
Cat.NotifyEventHandler notifyMouse = new Cat.NotifyEventHandler(mouse.Update);
cat.NotifyEvent += notifyMaster;
cat.NotifyEvent += notifyMouse;
cat.Notify();
}
应用场景：
对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可以变化。
对象仅需要将自己的更新通知给其他对象，而不需要知道其他对象的细节。
优点：
Subject 和obserer之间是送耦合的，分别可以各自独立改变。
Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否需要订阅Subject的通知。
遵守大部分GRASP原则和常用设计原则，高内聚，低耦合。
缺点：
如果一个Subject被大量的Observer订阅的话，在广播通知的时候可能会有效率问题。
相关原则
我们知道设计原则远比模式重要，学习设计模式的同时一定要注意体会设计原则的理念。现在我们看看观察者模式都符合的设计原则。
Identify the aspects of your application that vary and separate them from what stays the same(找到系统中变化的部分，将变化的部分同其他稳定的部分隔开). 在观察者模式的应用场景里面变化的部分是Subject的状态和Observer的数量。使用Observer模式可以很好的将这两部分隔离开，我们可以任意改变Observer的数量而不需要去修改Subject， 而Subject的状态也可以任意修改，同样不会对其Observer有任何影响。
Program to an interface ,not an implementation(面向接口编程，而不要面向实现编程) Subject和Observer都使用接口来实现。Subject只需要跟踪那些实现了IObserver接口的对象，所以其只依赖于IObserver；而所有Observer都通过ISubject接口来注册，撤销，接收通知，所有它们也只依赖于ISubject；所以是面向接口编程的，这样的实现方式使得Subject和Observer之间完全没有任何的耦合。
Favor composition over inheritance(优先使用对象组合，而非类继承) 观察者模式使用对象组合将Subject和若干Observer联系起来。它们之间的关系不是通过类的继承而是在运行时的动态组合。
原文转载出处：
https://blog.csdn.net/jxcr1984/article/details/53265038
