设计模式——观察者模式

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

　　观察者模式正如以上定义所说的，为了解决一个对象的状态改变，同时去改变另外几个对象的状态的一个设计模式。当然，那些观察者必须保持一致。

1.Subject类，抽象通知者类，定义并且实现了增加观察者，移除观察者，和通知观察者的方法。

/// <summary>
/// 抽象通知者
/// </summary>
public abstract class Subject
{
    //定义一个观察者对象
    private readonly IList<Observer> _observers = new List<Observer>();

    /// <summary>
    /// 增加观察者
    /// </summary>
    /// <param name="observer">观察者</param>
    public void Attach(Observer observer)
    {
        _observers.Add(observer);
    }

    /// <summary>
    /// 移除观察者
    /// </summary>
    /// <param name="observer">观察者</param>
    public void Detach(Observer observer)
    {
        _observers.Remove(observer);
    }

    /// <summary>
    /// 进行通知
    /// </summary>
    public void Notify()
    {
        foreach (var observer in _observers)
        {
            observer.Update();
        }
    }
}

2.ConcreteSubject类，定义了通知者的状态属性

/// <summary>
/// 具体通知者
/// </summary>
public class ConcreteSubject : Subject
{
    //被观察的状态
    public string SubjectState { get; set; }
}

3.Observer类，抽象观察者类，定义了观察者更新状态的抽象方法

4.ConcreteObserver类，具体的观察者类，根据构造方法得到通知者的状态改变，并进行跟新操作

/// <summary>
/// 具体观察者
/// </summary>
public class ConcreteObserver : Observer
{
    /// <summary>
    /// 观察者名字
    /// </summary>
    private readonly string _name;

    /// <summary>
    /// 观察者状态
    /// </summary>
    private string _observerState;


    private ConcreteSubject _concreteSubject;
    /// <summary>
    /// 通知者对象
    /// </summary>
    public ConcreteSubject ConcreteSubject
    {
        get { return _concreteSubject; }
        set { _concreteSubject = value; }
    }

    /// <summary>
    /// 具体观察者构造方法
    /// </summary>
    /// <param name="subject">通知者对象</param>
    /// <param name="name">观察者姓名</param>
    public ConcreteObserver(ConcreteSubject subject, string name)
    {
        _concreteSubject = subject;
        _name = name;
    }

    /// <summary>
    /// 状态更新
    /// </summary>
    public override void Update()
    {
        _observerState = _concreteSubject.SubjectState;
        Console.Write("观察者{0}的新状态是{1}", _name, _observerState);
    }
}

5.客户端代码，实例化通知者，并且添加观察者，改变通知者状态，观察者一起更新

class Program
{
    static void Main(string[] args)
    {

        var subject = new ConcreteSubject();

        subject.Attach(new ConcreteObserver(subject, "X"));

        subject.Attach(new ConcreteObserver(subject, "Y"));

        subject.SubjectState = "123";

        subject.Notify();
    }
}

　　以上的观察者模式是实现了一个状态改变，观察者状态改变。但是有一个缺点，那就是一个通知，所有的观察者的状态都改变了，而且改变的都一样，这样在实际开发中是很少遇见的，我们不希望为了维持一致性而使各类紧密耦合，这样会给维护和复用都带来不便。

　　所以，下面我们需要对观察者模式进行改进，会用.NET中一个特殊方法，那就是事件委托。

　　委托——委托就是一种引用方法的类型。一旦为委托分配了方法，委托将于该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对方法的抽象，是函数的“类”，委托的实例将代表一个具体的方法。

　　委托可以搭载多个方法，所有方法将被依次唤醒，委托所搭载的方法并不需要属于同一个类，只要参数和返回值类型一致就行了。

1.ISubject接口，定义了通知者的通知方法和状态属性

/// <summary>
/// 通知者接口
/// </summary>
public interface ISubject
{
    /// <summary>
    /// 进行通知
    /// </summary>
    void Notify();

    /// <summary>
    /// 通知者状态
    /// </summary>
    string SubjectState { get; set; }
}

2.Observer类，具体的观察者类，自身有不同的更新方法，但是参数和返回值一致，实现了什么可以不一致

/// <summary>
/// 股票行情观察者
/// </summary>
public class StockObserver
{
    private readonly string _name;
    private readonly ISubject _subject;

    
    public StockObserver(string mame, ISubject subject)
    {
        _name = mame;
        _subject = subject;
    }

    /// <summary>
    /// 原Update方法
    /// 先改成具体的差异化动作
    /// </summary>
    public void CloseStockMarket()
    {
        Console.WriteLine("{0}{1}关闭股票行情，继续工作", _subject.SubjectState, _name);
    }
}

/// <summary>
/// NBA直播观察者
/// </summary>
public class NBAObserver
{
    private readonly string _name;
    private readonly ISubject _subject;

    public NBAObserver(string mame, ISubject subject)
    {
        _name = mame;
        _subject = subject;
    }

    /// <summary>
    /// 原Update方法
    /// 先改成具体的差异化动作
    /// </summary>
    public void CloseNBADirectSeeding()
    {
        Console.WriteLine("{0}{1}关闭NBA直播，继续工作", _subject.SubjectState, _name);
    }
}

3.Subject类，具体的通知者，实现了接口的通知方法和状态属性,并且定义了一个委托，可以搭载各个观察者的更新需求

/// <summary>
/// 定义一个委托
/// 委托上的任务是给观察者通知
/// </summary>
public delegate void EventHandeler();

/// <summary>
/// 通知者，实现通知接口
/// </summary>
public class Boss : ISubject
{
    /// <summary>
    /// 实例化委托
    /// </summary>
    public event EventHandeler Update;

    /// <summary>
    /// 调用委托方法去进行通知
    /// 委托可以使委托链
    /// 那么可以同时实现多种通知
    /// </summary>
    public void Notify()
    {
        Update();
    }

    /// <summary>
    /// 实现接口的通知状态属性
    /// </summary>
    public string SubjectState { get; set; }
}

public class Secretary : ISubject
{
    public event EventHandeler Update;

    public void Notify()
    {
        Update();
    }

    string ISubject.SubjectState { get; set; }
}

4.客户端代码，创建通知者对象，并创建观察者对象，将观察者的更新需求搭载进通知者的委托链，然后改变通知者的状态，发出通知，观察者进行自我更新

class Program
{
    static void Main(string[] args)
    {
        //创建通知者老板
        var boss = new Boss();

        //创建具体的观察者同事

        var colleague1 = new StockObserver("张三 ", boss);

        var colleague2 = new NBAObserver("李四 ", boss);

        //给通知者添加通知的事件
        boss.Update+=new EventHandeler(colleague1.CloseStockMarket);
        boss.Update+=new EventHandeler(colleague2.CloseNBADirectSeeding);

        //老板回来了，状态更改
        boss.SubjectState = "我胡汉三又回来啦，";
        //老板作为通知者通知观察者
        boss.Notify();
        Console.ReadKey();

    }
}

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　以上内容部分参考程杰的《大话设计模式》一书