行为型模式：Observer 观察者模式

                                                           行为型模式：Observer 观察者模式

１、发布－订阅模型
  ATM机取款时，诊赖于ATM机的各种信息都要更新，ATM就是一个观察者。
 
２、动机（Motivation）
  １）在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。
  ２）使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。
 
３、意图（Intent）
  定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有的依赖于它的对象都得到通知并自动更新。
                                                                                                ——《设计模式》GoF
 
４、实例：ATM机取款
  １、拿到需求时的设计如下：
//ATM机
public class ATM
{
  //银行帐户
  private BankAccout bankAccout;
 
  public void Process(int data)
  {
    bankAccount.Withdraw(data);
  }
}

//银行帐户类
public class BankAccount
{
  private Emailer emailer;//强依赖关系：紧耦合
  private Mobile mobile;  //强依赖关系：紧耦合
  //用依赖倒置原则解决这个强依赖问题，让实现细节依赖于抽象
  private string userEmail = "";
  private string phoneNumber = "";
 
  public void Withdraw(int data)
  {
    //...
    emailer.SendEmail(userEmail);
    mobile.SendNotification(phoneNumber);
  }
}

//通知用户帐号的Email
public class Emailer
{
  public void SendEmail(string toAddress)
  {
  }
}

//短信通知用户
public class  Mobile
{
  public void SendNotification(string phoneNumber)
  {
  }
}

  ２、由于变化，依据依赖倒置原则，提取出抽象，设计为观察者模式：
//帐户类也不稳定，抽像出一个抽象类
public abstract class Subject
{
  private List<IAccountObserver> observerList = List<IAccountObserver>();
 
  //用各种方法通知到用户
  //也许会更改，声明成虚方法
  protected virtual void Notify(UserAccountArgs args)
  {
    foreach (IAccountObserver observer in observerList)
    {
      observer.Update(args);
    }
  }
 
  //添加IAccountObserver
  public void AddObserver(IAccountObserver observer)
  {
    observerList.Add(observer);
  }
 
  //删除
  public void RemoveObserver(IAccountObserver observer)
  {
    observerList.Remove(observer);
  }
}

//银行帐户类
public class BankAccount : Subject
{
  //取钱后要更新
  public void Withdraw(int data)
  {
    //...取钱
    UserAccountArgs args = new UserAccoountArgs();
    //...
    Notify(args);
  }
}

//通知的内容
public class UserAccountArgs
{
  private string toAddress;
  private string mobileNumber;
 
  public string ToAddress
  {
    get { return this.toAddress; }
    set { this.toAddress = value; }
  }
 
  public string MobileNumber
  {
    get { return this.mobileNumber; }
    set { this.mobileNumber = value; }
  }
}

//提取的接口（通知用户的方法）
public interface IAccountObserver
{
  void Update(UserAccountArgs args);
}

//邮件通知
public class Emailer : IAccountObserver
{
  public void Update(UserAccountArgs args)
  {
    //...
    string toAddress = args.ToAddress;
  }
}

//手机通知
public class Mobile : IAccountObserver
{
  public void Update(UserAccountArgs args)
  {
    //...
    string moblieNumber = args.MobileNumber;
  }
}

  分析：BankAccount类依赖于Subject抽象类；
        Subject抽象类依赖于IAccountObserver接口；
        Emailer类和Mobile类都依赖于IAccountObserver接口。

  ３、用事件的方式实现
//定义委托
public delegate void AccountChangeEventHandler(object sender, AccountChangeEventArgs args);

//银行帐户类
public class BankAccount
{
  //定义事件
  public event AccountChangeEventHandler AccountChange;
 
  public void Withdraw(int data)
  {
    //...取钱
    AccountChangeEventArgs args = new AccountChangeEventArgs();
    //...
    OnAccountChange(args);
  }
 
  protected virtual void OnAccountChange(AccountChangeEventArgs args))
  {
    if (AccountChange != null)
    {
      AccountChange(args);
    }
  }
}

//邮件通知
public class Emailer
{
  public void Update(object sender, AccountChangeEventArgs args)
  {
    //...
    string toAddress = args.ToAddress;
  }
}

class ATM
{
  public static void Main()
  {
    BankAccount bankAccount = new BankAccount();
    Emailer emailer = new Emailer();
    bankAccount.AccountChange += new AccountChangeEventHandler(emailer.Update);
   
    bankAccount.Withdraw(1234);
  }
}

５、Observer模式的几个要点
  １）使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达致松耦合。
  ２）目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知，目标对象对此一无所知。
  ３）在C#的event中，委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象。委托是比抽象Observer接口更为松耦合的设计。