这个是 昨天 练习 事件代理 的时候想到 的.
于是今天就 试一把
由于昨天 写的 那个程序
基本功能: 在 Cat 类对象 Shout() 之后 订阅 事件 的 所有 Mouse 类对象都 会 执行 Run() 方法;.
但是 在每次 有 新的 事件订阅者的时候 必须 添加 一行
tomcat.CatShoutEvent +=new CatShoutEventHandler(jacky.run);
这一点我想 设计成 只要 声明了的mouse类对象 ,都会自动执行 响应函数;
ok! 开始了
存在问题:
1. 如何在 对象 创建时 便让 其他类 知道
2. 如何 全局 获取 并通知 所有 对象执行相应的方法
解决方法 : 用单例模式的思想 来获得 一个 对象 而且 该 使用 该对象 保存所有 Mouse 类的 对象的 引用 ,
同时应用 Observer 模式 , 通知所有 类对象 来执行 相应的方法..
文件结构
│ AbstractCat.cs ---------Cat 的 抽象类
│ AbstractMouse.cs----------Mouse 的 抽象类
│ Cat.cs ----------Cat 类
│ ITalk.cs ----------Talk能力接口
│ Mouse.cs ----------Mouse
│ Program.cs ---------主函数 所在类
│ ShoutEventArgs.cs---------时间参数类 继承自 EventArgs
│ SuperCat.cs ----------超级猫 类
│ SuperMouse.cs -----------超级 老鼠 类
├─MouseFactory 工厂方法所在包: 生产 老鼠
│ IFactory.cs -------工厂接口
│ mouseFactory.cs -------生产 Mouse
│ superMouseFactory.cs --------生产超级老鼠
│
├─Observer ---------Observer模式 所在包:
│ IObserver.cs ---------Observer接口
│ Observable.cs ----------- 事件通知者类: 其间 包含 所有 Mouse对象 的 引用 ,还有 通知 所有Mouse 对象 执行 对 猫的shout() 之后的 Action 方法
将 Observer 声明为 接口 使得 所有的 实现了 该接口的 类 都可以 被通知
IObserver.cs:
2 {
3 void Action( object sender,ShoutEventArgs e);
4 }
Observable.cs :
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5
6 namespace delegateTry.Observer
7 {
8 class Observable
9 {
10 private IList < IObserver > mouses;
11
12 private static Observable observable;
13
14 private static readonly object syncForLock = new object ();
15
16 private Observable()
17 {
18 mouses = new List < IObserver > ();
19 }
20
21 // 单线程情况
22 public static Observable GetInstance()
23 {
24 if (observable == null )
25 {
26 observable = new Observable();
27
28 return observable;
29 }
30
31 else
32 {
33 return observable;
34 }
35 }
36
37 // 多线程
38 /*
39 * 在本程序中没用上
40 */
41
42 public static Observable GetInstanceForSecurity()
43 {
44 if (observable == null )
45 {
46 lock (syncForLock)
47 {
48 if (observable == null )
49 {
50 observable = new Observable();
51 }
52 }
53
54 return observable;
55 }
56
57 else
58 {
59 return observable;
60 }
61 }
62
63 // 添加 订阅者 或者说 观察者
64 public void AddObserver(IObserver amouse)
65 {
66 this .mouses.Add(amouse);
67 }
68
69 // 删除 订阅者 或者说 观察者 对象
70 public void DelObserver(IObserver amouse)
71 {
72 this .mouses.Remove(amouse);
73 }
74
75
76 // 观察者 的反应
77 public void Action( object sender ,ShoutEventArgs e)
78 {
79 foreach (IObserver item in this .mouses)
80 {
81 item.Action(sender,e);
82 }
83 }
84
85 }
86 }
87
上面 使用单例 来 使得 所有 实现了 Iobserver 对象 的 引用 都可以 被 存放在 同一 个 对象中.; 并且 在 事件 被触发时 都被通知到
如何 保证 Mouse 对象的 引用 都被 存放进 Observer 的同一个对象中 呢...?
这里使用 factory Method 来 生产对象 同时 做一点 无耻的 工作.
2 {
3
4 AbstractMouse concreteMouse( string name);
5
6 }
Mousefactory.cs :
2 {
3
4 public AbstractMouse concreteMouse( string name)
5 {
6 AbstractMouse am = new Mouse(name);
7
8 // 将其加入到 观察者对象列表中
9 Observable.GetInstance().AddObserver(am);
10
11 return am;
12
13 }
14
15 }
用这种方法 就在 生成对象 的时候 自动 的 将 引用 传递给了 Observer 对象 保存起来; 不用操心 了.
大概就是这样 ,;
贴一下 Mouse 和 Cat 类 的代码:
因为 稍微做了一下 抽象 提取 所以 还蛮多的;
2
3 abstract class AbstractCat
4 {
5 public event CatShoutEventHandler CatShoutEvent;
6
7 protected string name;
8
9
10 public AbstractCat( string name)
11 {
12 this .name = name;
13
14 }
15
16
17 public string Name
18 {
19 get
20 {
21 return name;
22 }
23 }
24
25 public virtual void Shout()
26 {
27
28 if ( this .CatShoutEvent != null )
29 {
30 this .CatShoutEvent( this , new ShoutEventArgs( this .name));
31 }
32
33 }
34 }
1 class Cat:AbstractCat
3 public Cat( string name): base (name)
4 {
5
6 }
7
8 public override void Shout()
9 {
10 Console.WriteLine( " 我只会 喵..喵..----普通猫 \n\n " , this .name);
11 base .Shout();
12 }
13 }
2 {
3 public SuperCat( string name)
4 : base (name)
5 {
6
7 }
8
9 public string Talk()
10 {
11 return ( " bull shit! cut your crap!\n " );
12 }
13
14
15 public override void Shout()
16 {
17 Console.WriteLine( " ! this is {0}
.! 哈哈..
"
,
this
.name);18
19 Console.WriteLine(Talk());
20
21 base .Shout();
22
23 }
24
25 }
AbstractMouse 类
2 {
3 protected string name;
4
5 public AbstractMouse( string name)
6 {
7 this .name = name;
8
9 }
10
11 public virtual void run( object sender, ShoutEventArgs e)
12 {
13
14 }
15
16 public virtual void Action( object sender, ShoutEventArgs e)
17 {
18 run(sender,e);
19 }
20
21 }
2 {
3 public Mouse( string name)
4 : base (name)
5 {
6
7 }
8
9
10 public override void run( object sender,ShoutEventArgs e)
11 {
12 Console.WriteLine( " {0} 来了, 我 {1} 开溜! " ,e.ShoutSource, this .name);
13 }
14
15 }
2 {
3 public SuperMouse( string name): base (name)
4 {
5
6 }
7
8 public string Talk()
9 {
10 return string .Format( " Stop !, this is {0}, Let's hava a negotiation! \n " , this .name);
11 }
12
13 public override void run( object sender, ShoutEventArgs e)
14 {
15 if (sender is SuperCat)
16 {
17 Console.WriteLine( " {0} :: {1} \n " , e.ShoutSource, Talk());
18 }
19
20 else
21 {
22
23 Console.WriteLine( " 碰上个 傻瓜猫 今天
快逃命吧 \n
"
, e.ShoutSource, Talk());24
25 }
26
27 }
28
29
30 }
再看下主函数:
1 class Program
3 static void Main( string [] args)
4 {
5 AbstractCat tomcat = new Cat( " Tomcat " );
6 AbstractCat SuperTomcat = new SuperCat( " 超级猫 " );
7
8 IFactory mouseFac = new mouseFactory();
9 IFactory superFac = new superMouseFactory();
10
11 AbstractMouse jacky = mouseFac.concreteMouse( " Tacky " );
12 AbstractMouse mikky = mouseFac.concreteMouse( " Mikky " );
13
14
15 AbstractMouse mickeyMouse = superFac.concreteMouse( " 米老鼠 " );
16
17
18 tomcat.CatShoutEvent += new CatShoutEventHandler(Observable.GetInstance().Action);
19
20 SuperTomcat.CatShoutEvent += new CatShoutEventHandler(Observable.GetInstance().Action);
21
22
23 tomcat.Shout();
24
25
26 Console.WriteLine( " Tomcat shorting ends here \n\n " );
27
28
29 Console.WriteLine( " SuperTomcat shorting begins here \n\n " );
30
31
32 SuperTomcat.Shout();
33
34
35 Console.Read();
36
37 }
38 }
主程序中 在 Cat 对象 Shout() 之后 并未 声明 通知所有 的 Mouse 对象 ; 但是 所有的 Mouse 对象 都会对此 做出 反应;
程序 运行结果 :
116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
