观察者模式（Observer）：

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

观察者模式的角色：

　　 

　　1）抽象目标（Subject）：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。 

　　2）具体目标（ConcreteSubject）：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。 

　　3）抽象观察者（Observer）：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。 

　　4）具体观察者（ConcreteObserver）：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。 

internal class Program
{
    private static void Main(string[] args)
    {
        Subject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver1();
        Observer observer2 = new ConcreteObserver2();
        subject.Attach(observer1);
        subject.Attach(observer2);
        subject.Notify();
    }
}

/// <summary>
/// 抽象目标
/// </summary>
internal abstract class Subject
{
    /// <summary>
    /// 新增观察者
    /// </summary>
    /// <param name="o"></param>
    public abstract void Attach(Observer o);

    /// <summary>
    /// 删除观察者
    /// </summary>
    /// <param name="o"></param>
    public abstract void Detach(Observer o);

    /// <summary>
    /// 通知观察者
    /// </summary>
    public abstract void Notify();
}

/// <summary>
/// 抽象观察者
/// </summary>
internal abstract class Observer
{
    public abstract void update();
}

/// <summary>
/// 具体目标
/// </summary>
internal class ConcreteSubject : Subject
{
    private System.Collections.Generic.List<Observer> observers
        = new System.Collections.Generic.List<Observer>();

    public override void Attach(Observer o)
    {
        if (o != null)
            observers.Add(o);
    }

    public override void Detach(Observer o)
    {
        if (o != null)
            observers.Remove(o);
    }

    public override void Notify()
    {
        Console.WriteLine("目标发生变化");
        foreach (var observer in observers)
        {
            observer.update();
        }
    }
}

/// <summary>
/// 具体观察者1
/// </summary>
internal class ConcreteObserver1 : Observer
{
    public override void update()
    {
        Console.WriteLine("观察者1更新");
    }
}

/// <summary>
/// 具体观察者2
/// </summary>
internal class ConcreteObserver2 : Observer
{
    public override void update()
    {
        Console.WriteLine("观察者2更新");
    }
}

 事例：

　　学校的“铃”是事件源和目标，"学生"是事件监听器和具体观察者，"铃声"是事件类。当下课时间到，会触发铃发声，这时会生成“铃声”事件；学生就会做一些事情。。。

internal class Program
{
    private static void Main(string[] args)
    {
        // 创建下课铃声
        Bell subject = new FinishClassBell();
        // 创建观察者
        Observer xiaoming = new XiaoMing();
        Observer xiaohong = new XiaoHong();
        Observer xiaowang = new XiaoWang();
        // 观察者随着听着下课铃
        subject.Attach(xiaoming);
        subject.Attach(xiaohong);
        subject.Attach(xiaowang);
        // 下课铃响了，通知大家
        subject.Notify();
    }
}

/// <summary>
/// 铃声：抽象目标
/// </summary>
internal abstract class Bell
{
    /// <summary>
    /// 新增观察者
    /// </summary>
    /// <param name="o"></param>
    public abstract void Attach(Observer