在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如，某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。

在软件世界也是这样，例如，事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。

定义与特点

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

观察者模式是一种对象行为型模式，其主要优点如下：

降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
目标与观察者之间建立了一套触发机制。

它的主要缺点如下：

目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

结构与实现

实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。

模式的结构

观察者模式的主要角色如下：

抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

观察者模式的结构图如图所示：

模式的实现

观察者模式的实现代码如下：

class Program
{
    static void Main(string[] args)
    {
        Subject subject=new ConcreteSubject();
        IObserver obs1=new ConcreteObserver1();
        IObserver obs2=new ConcreteObserver2();
        subject.Add(obs1);
        subject.Add(obs2);
        subject.NotifyObserver();
        Console.Read();
    }
}

//抽象目标
public abstract class Subject
{
    protected List<IObserver> observers=new List<IObserver>();
    //增加观察者方法
    public void Add(IObserver observer)
    {
        observers.Add(observer);
    }
    //删除观察者方法
    public void Remove(IObserver observer)
    {
        observers.Remove(observer);
    }
    public abstract void NotifyObserver(); //通知观察者方法
}

//具体目标
public class ConcreteSubject : Subject
{
    public override  void NotifyObserver()
    {
        Console.WriteLine("具体目标发生改变...");
        Console.WriteLine("--------------");       

        foreach (var obs in observers)
    {
            obs.Response();
    }
    }
}

//抽象观察者
public interface IObserver
{
    void Response(); //反应
}

//具体观察者1
public class ConcreteObserver1 : IObserver
{
    public void Response()
    {
        Console.WriteLine("具体观察者1作出反应！");
    }
}

//具体观察者1
public class ConcreteObserver2 : IObserver
{
    public void Response()
    {
        Console.WriteLine("具体观察者2作出反应！");
    }
}

程序运行结果如下：

具体目标发生改变...
--------------
具体观察者1作出反应！
具体观察者2作出反应！

应用场景

通过前面的分析与应用实例可知观察者模式适合以下几种情形：

对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

扩展：.net中的IObservable和 IObserver接口

在.net环境下，其运行时库为开发者提供了IObservable和 IObserver接口，用于实现观察者模式软件设计。另外，ObservableCollection 类表示一个动态数据集合，它可在添加、删除项目或刷新整个列表时提供通知。

提供者或主题，是将通知发送给观察者的对象。 提供程序是实现IObservable接口的类或结构。提供者必须实现单个方法IObservable.Subscribe，该方法由希望从提供者接收通知的观察者调用。

观察者，即从提供程序接收通知的对象。 观察者是实现 IObserver接口的类或结构。观察者必须实现以下三个方法，这三个方法均由提供程序调用：
IObserver.OnNext，它向观察者提供新信息或当前信息。
IObserver.OnError，它通知观察者已发生错误。
IObserver.OnCompleted，它指示提供程序已完成发送通知。

允许提供程序跟踪观察者的一种机制。通常情况下，提供程序使用容器对象（如 List对象）来保存对已订阅通知的 IObserver实现的引用。将存储容器用于此目的使提供程序能够处理零到无限数量的观察者。未定义观察者接收通知的顺序；提供程序可以随意使用任何方法来确定顺序。

IDisposable 实现，它使提供程序在能够通知完成时删除观察者。观察者从 Subscribe 方法接收对 IDisposable 实现的引用，因此它们还可以调用 IDisposable.Dispose 方法，以便在提供程序已完成发送通知之前取消订阅。

包含提供程序发送到其观察者的数据的对象。此对象的类型对应 IObservable和 IObserver接口的泛型类型参数。尽管此对象可与 IObservable

实现相同，但通常情况下，它是一个单独的类型。

注：在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

下面的示例演示观察者设计模式，实现定位系统实时通知当前经纬度坐标，代码如下：

class Program
{
    static void Main(string[] args)
    {
        // 定义一个提供者和两个观察者
        LocationTracker provider = new LocationTracker();
        LocationReporter reporter1 = new LocationReporter("FixedGPS");
        reporter1.Subscribe(provider);
        LocationReporter reporter2 = new LocationReporter("MobileGPS");
        reporter2.Subscribe(provider);

        provider.TrackLocation(new Location(47.6456, -122.1312));
        reporter1.Unsubscribe();
        provider.TrackLocation(new Location(47.6677, -122.1199));
        provider.TrackLocation(null);
        provider.EndTransmission();

        Console.Read();
    }
}

/// <summary>
/// 位置：包含纬度和经度信息
/// </summary>
public struct Location
{
    double lat, lon;

    public Location(double latitude, double longitude)
    {
        this.lat = latitude;
        this.lon = longitude;
    }

    /// <summary>
    /// 纬度
    /// </summary>
    public double Latitude
    { get { return this.lat; } }
    /// <summary>
    /// 经度
    /// </summary>
    public double Longitude
    { get { return this.lon; } }
}

/// <summary>
/// 位置报告者：提供 IObserver<T> 实现，它显示有关当前控制台位置的信息
/// </summary>
public class LocationReporter : IObserver<Location>
{
    private IDisposable unsubscriber;
    private string instName;

    public LocationReporter(string name)
    {
        this.instName = name;
    }

    public string Name
    { get { return this.instName; } }

    /// <summary>
    /// 订阅：将由对 Subscribe 的调用返回的 IDisposable 实现保存到私有变量中
    /// </summary>
    /// <param name="provider"></param>
    public virtual void Subscribe(IObservable<Location> provider)
    {
        if (provider != null)
            unsubscriber = provider.Subscribe(this);
    }

    public virtual void OnCompleted()
    {
        Console.WriteLine("位置跟踪器已将数据传输到 {0}", this.Name);
        this.Unsubscribe();
    }

    public virtual void OnError(Exception e)
    {
        Console.WriteLine("{0}: 无法确定位置", this.Name);
    }

    public virtual void OnNext(Location value)
    {
        Console.WriteLine("{2}: 当前位置是 {0}, {1}", value.Latitude, value.Longitude, this.Name);
    }

    /// <summary>
    /// 退订：使类可以通过调用提供程序的 Dispose 实现来取消订阅通知
    /// </summary>
    public virtual void Unsubscribe()
    {
        unsubscriber.Dispose();
    }
}

/// <summary>
/// 位置跟踪器：提供 IObservable<T> 实现
/// </summary>
public class LocationTracker : IObservable<Location>
{
    public LocationTracker()
    {
        observers = new List<IObserver<Location>>();
    }

    private List<IObserver<Location>> observers;

    /// <summary>
    /// 订阅：某观察程序将要接收通知
    /// </summary>
    /// <param name="observer"></param>
    /// <returns></returns>
    public IDisposable Subscribe(IObserver<Location> observer)
    {
        if (!observers.Contains(observer))
            observers.Add(observer);
        return new Unsubscriber(observers, observer);
    }

    /// <summary>
    /// IDisposable 实现：用于删除观察者或取消订阅
    /// </summary>
    private class Unsubscriber : IDisposable
    {
        private List<IObserver<Location>> _observers;
        private IObserver<Location> _observer;

        public Unsubscriber(List<IObserver<Location>> observers, IObserver<Location> observer)
        {
            this._observers = observers;
            this._observer = observer;
        }

        public void Dispose()
        {
            if (_observer != null && _observers.Contains(_observer))
                _observers.Remove(_observer);
        }
    }

    public void TrackLocation(Nullable<Location> loc)
    {
        foreach (var observer in observers)
        {
            if (!loc.HasValue)
                observer.OnError(new LocationUnknownException());
            else
                observer.OnNext(loc.Value);
        }
    }

    public void EndTransmission()
    {
        foreach (var observer in observers.ToArray())
        {
            if (observers.Contains(observer))
                observer.OnCompleted();
        }
        observers.Clear();
    }
}

/// <summary>
/// 位置未知异常
/// </summary>
public class LocationUnknownException : Exception
{
    internal LocationUnknownException()
    { }
}