观察者模式:定义对象间的一种一对多的依赖关系,使得每当一个对象改变状态时,则其他相关依赖对象皆得到通知并被自动更新。
实现一:被观察者需要有添加和删除观察者的功能,当被观察者状态变化时,调用其观察者的更新函数。
猫和老鼠
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace mouseANDcat
{
public interface Observer
{
void Response();
}
public interface Subject
{
void AimAt(Observer obs);
}
public class Mouse : Observer
{
private string name;
public Mouse(string name, Subject subj)
{
this.name = name;
subj.AimAt(this);
}
public void Response()
{
Console.WriteLine(name + "努力逃跑!");
}
}
public class Cat : Subject
{
private ArrayList observers;
public Cat()
{
observers = new ArrayList();
}
public void AimAt(Observer obs)
{
this.observers.Add(obs);
}
public void Cry()
{
Console.WriteLine("猫叫了!");
foreach (Observer obs in this.observers)
{
obs.Response();
}
}
}
class Program
{
static void Main(string[] args)
{
Cat cat = new Cat();
Mouse mouse1 = new Mouse("小老鼠", cat);
Mouse mouse2 = new Mouse("大老鼠", cat);
cat.Cry();
Console.Read();
}
}
}
股票变化
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace 股票变化
{
abstract class Stock
{
protected string symbol;
protected double price;
private ArrayList investors = new ArrayList();
public Stock(string symbol, double price)
{
this.symbol = symbol;
this.price = price;
}
public void Attach(Investor investor)
{
investors.Add(investor);
}
public void Detach(Investor investor)
{
investors.Remove(investor);
}
public void Notify()
{
foreach (Investor i in investors)
i.Update(this);
}
public double Price
{
get { return price; }
set
{
price = value;
Notify();
}
}
public string Symbol
{
get { return symbol; }
set { symbol = value; }
}
}
class IBM : Stock
{
public IBM(string symbol, double price) : base(symbol, price) { }
}
interface IInvestor
{
void Update(Stock stock);
}
class Investor : IInvestor
{
private string name;
private Stock stock;
public Investor(string name)
{
this.name = name;
}
public void Update(Stock stock)
{
Console.WriteLine("通知到股民{0} {1} 最新股价为:{2:C}", name, stock.Symbol, stock.Price);
}
public Stock Stock
{
get { return stock; }
set { stock = value; }
}
}
class Program
{
static void Main(string[] args)
{
Investor s = new Investor("张三");
Investor b = new Investor("李四");
IBM ibm = new IBM("IBM", 120.00);
ibm.Attach(s);
ibm.Attach(b);
ibm.Price = 120.10;
ibm.Price = 121.00;
ibm.Price = 120.50;
ibm.Price = 120.75;
Console.Read();
}
}
}
二:利用C#的事件委托,被观察者中无需添加和删除观察者函数。
using System;
using System.Collections.Generic;
using System.Text;
namespace 委托实现观察者模式
{
class StockObserver
{
private string name;
private Subject sub;
public StockObserver(string name, Subject sub)
{
this.name = name;
this.sub = sub;
}
public void CloseStockMarket()
{
Console.WriteLine("{0} {1} 关闭股票行情,继续工作!", sub.SubjectState, name);
}
}
class NBAobserver
{
private string name;
private Subject sub;
public NBAobserver(string name, Subject sub)
{
this.name = name;
this.sub = sub;
}
public void CloseNBADirectSeeding()
{
Console.WriteLine("{0} {1} 关闭NBA直播,继续工作!", sub.SubjectState, name);
}
}
interface Subject
{
void Notify();
string SubjectState
{
get;
set;
}
}
delegate void EventHandler();
class Boss : Subject
{
public event EventHandler Update;
private string action;
public void Notify()
{
Update();
}
public string SubjectState
{
get { return action; }
set { action = value; }
}
}
class Program
{
static void Main(string[] args)
{
Boss huhansan = new Boss();
StockObserver tongshi1 = new StockObserver("魏关姹", huhansan);
NBAobserver tongshi2 = new NBAobserver("易管查",huhansan);
huhansan.Update += new EventHandler(tongshi1.CloseStockMarket);
huhansan.Update += new EventHandler(tongshi2.CloseNBADirectSeeding);
huhansan.SubjectState = "我胡汉三回来了!";
huhansan.Notify();
Console.Read();
}
}
}