.net设计模式-观察者模式

行为型设计模式:关注对象和行为的分离

观察者模式:解决一个对象里面某件事情发生后，会触发一系列其他对象的动作，然后不希望对象之间紧密依赖问题  

有一个猫叫的类,它如果执行miao的方法,会有一系列的动作触发

 1 public class Cat
 2     {
 3         public void Miao()
 4         {
 5             Console.WriteLine("{0} Miao.....", this.GetType().Name);
 6 
 7             new Dog().Wang(3);
 8             //new Mouse().Run();
 9             new Chicken().Woo();
10             new Baby().Cry();
11             new Brother().Turn();
12             new Father().Roar();
13             new Mother().Whisper();
14             //new Mouse().Run();
15             new Neighbor().Awake();
16             new Stealer().Hide();
17         }
18 
19 }

但是这就造成了耦合,因为如果要求少一个动作或者加一个动作去执行,再或者是需要改变调用的方法的名称,这就都需要在Cat的方法中去修改,太麻烦了

所以此时应该用一个万能的方法去解决这个问题--就是转移,把执行对象的序列(顺序)和到底要执行哪个方法都交给上端调用的人去指定

 

1.观察者模式:面向对象的解决方式

规定一个接口,有一个方法

1  public interface IObserver
2     {
3         void Action();
4     }

各个触发动作都去实现这个接口

 1 public class Baby : IObserver
 2     {
 3         public void Action()
 4         {
 5             this.Cry();
 6         }
 7 
 8         public void Cry()
 9         {
10             Console.WriteLine("{0} Cry", this.GetType().Name);
11         }
12     }

 1  public class Brother : IObserver
 2     {
 3         public void Action()
 4         {
 5             this.Turn();
 6         }
 7         public void Turn()
 8         {
 9             Console.WriteLine("{0} Turn", this.GetType().Name);
10         }
11     }

 1  public class Chicken : IObserver
 2     {
 3         public void Action()
 4         {
 5             this.Woo();
 6         }
 7         public void Woo()
 8         {
 9             Console.WriteLine("{0} Woo", this.GetType().Name);
10         }
11     }

等等动作的实现

cat类的定义,添加AddObserver接口,让上端来添加动作

 1  public class Cat
 2     {
 3        
 4         private List _ObserverList = new List();
 5         public void AddObserver(IObserver observer)
 6         {
 7             this._ObserverList.Add(observer);
 8         }
 9         public void MiaoObserver()
10         {
11             Console.WriteLine("{0} MiaoObserver.....", this.GetType().Name);
12             if (this._ObserverList != null)
13             {
14                 foreach (var observer in _ObserverList)
15                 {
16                     observer.Action();
17                 }
18             }
19         }
20 }

调用

 1   {
 2                     Console.WriteLine("************************");
 3                     Cat cat = new Cat();
 4                     cat.AddObserver(new Dog());
 5                     cat.AddObserver(new Mouse());
 6                     cat.AddObserver(new Chicken());
 7                     cat.AddObserver(new Baby());
 8                     cat.AddObserver(new Brother());
 9                     cat.AddObserver(new Father());
10                     cat.AddObserver(new Mother());
11                     cat.AddObserver(new Neighbor());
12                     cat.AddObserver(new Stealer());
13                     cat.MiaoObserver();
14                 }

 2.观察者模式:应用事件(多播委托)的解决方式

 cat的定义

 1  public class Cat
 2     {
 3       
 4       
 5 
 6         public event Action MiaoHandler;
 7         public void MiaoEvent()
 8         {
 9             Console.WriteLine("{0} MiaoEvent.....", this.GetType().Name);
10             if (this.MiaoHandler != null)
11             {
12                 //foreach (Action action in this.MiaoHandler.GetInvocationList())
13                 //{
14                 //    action.Invoke();
15                 //}
16                 this.MiaoHandler.Invoke();
17             }
18         }
19 
20 
21 
22     }

调用

 1   {
 2                     Console.WriteLine("************************");
 3                     Cat cat = new Cat();
 4                     //cat.MiaoHandler += new Action(new Dog().Wang);
 5 
 6                     cat.MiaoHandler += new Action(() => new Dog().Wang(3));
 7 
 8                     cat.MiaoHandler += new Mouse().Run;
 9                     cat.MiaoHandler += new Chicken().Woo;
10                     cat.MiaoHandler += new Baby().Cry;
11                     cat.MiaoHandler += new Brother().Turn;
12                     cat.MiaoHandler += new Father().Roar;
13                     cat.MiaoHandler += new Mother().Whisper;
14                     cat.MiaoHandler += new Neighbor().Awake;
15                     cat.MiaoHandler += new Stealer().Hide;
16                     cat.MiaoEvent();
17                 }

 

观察者模式帮助我们解决 在一个方法中的多个动作的个数和调用顺序等等常常发生变化的情境  通过上述两个方法将问题转移给上端,让上端根据不同的情况去处理

 

转载于:https://www.cnblogs.com/Spinoza/p/11520526.html