c#设计模式之观察者模式(Observer Pattern)

场景出发

一个月高风黑的晚上,突然传来了尖锐的猫叫,宁静被彻底打破,狗开始吠了,大人醒了,婴儿哭了,小偷跑了

这个过程,如果用面向对象语言来描述,简单莫过于下:

    public class Cat
     {
         public void Miao()
         {
             Console.WriteLine("猫叫了..........");

             new Dog().Wang();
             new Parents().Wake();
             new Baby().Cry();
             new Thief().Run();
         }
     }
     public class Dog
     {
         public void Wang()
         {
             Console.WriteLine("狗汪了..........");
         }
     }

     public class Parents
     {
         public void Wake()
         {
             Console.WriteLine("大人醒了..........");
         }
     }

     public class Baby
     {
         public void Cry()
         {
             Console.WriteLine("婴儿哭了..........");
         }
     }

     public class Thief
     {
         public void Run()
         {
             Console.WriteLine("小偷跑了..........");
         }
     }

Object

     class Program
     {
         static void Main(string[] args)
         {
             Cat cat = new Cat();
             cat.Miao();
         }
     }

Main

代码分析

分析上述代码,显然违背了面向对象语言几大原则中的:

1单一职责原则:猫这个对象的内部还依赖其他对象细节,致使其本来的职责与其他对象的职责耦合在一起

2开闭原则(Open-Closed Principle,OCP):即对扩展开放,对修改关闭,很显然,如果我们要扩展,例如改变上述动作的顺序,那么我们就不得不去修改猫内部代码

上述代码问题的核心:猫这个对象很不稳定,在我们整个过程中,猫应该是独立存在,且不能够修改的

观察者模式

针对上面的问题场景,在面向对象语言中有一种适用的设计模式——观察者模式

观察者模式将上述对象分为2类:

主题(Subject):被关注的对象,当它的状态发生变化时,会触发观察者的反应,上述的猫就是一个主题,它发出猫叫这个状态变化的信号

观察者(或订阅者,Observer):即关注主题的对象,当主题的状态发生变化,它们会做出反应,上述的狗,大人,婴儿,小偷都是观察者

观察者模式采用的方式是将主题对观察者的直接依赖,转为对它们的抽象的依赖,具体代码如下:

    /// <summary>
     /// 观察者的抽象
     /// </summary>
     public interface IObserver
     {
         void Action();
     }

IObserver

     /// <summary>
     /// 主题
     /// </summary>
     public class Cat
     {
         /// <summary>
         /// 观察者集合
         /// </summary>
         private List<IObserver> _observerList = new List<IObserver>();
         /// <summary>
         /// 添加观察者
         /// </summary>
         /// <param name="observer"></param>
         public void AddObserver(IObserver observer)
         {
             _observerList.Add(observer);
         }
         /// <summary>
         /// 状态变化
         /// </summary>
         public void Miao()
         {
             Console.WriteLine("猫叫了..........");

             ///后续动作
             foreach (var item in _observerList)
             {
                 item.Action();
             }
         }
     }

Subject

     public class Dog : IObserver
     {
         public void Wang()
         {
             Console.WriteLine("狗汪了..........");
         }
         public void Action()
         {
             Wang();
         }
     }

     public class Parents : IObserver
     {
         public void Wake()
         {
             Console.WriteLine("大人醒了..........");
         }
         public void Action()
         {
             Wake();
         }
     }

     public class Baby : IObserver
     {
         public void Cry()
         {
             Console.WriteLine("婴儿哭了..........");
         }
         public void Action()
         {
             Cry();
         }
     }

     public class Thief : IObserver
     {
         public void Run()
         {
             Console.WriteLine("小偷跑了..........");
         }
         public void Action()
         {
             Run();
         }
     }

Observers

     class Program
     {
         static void Main(string[] args)
         {
             Cat cat = new Cat();
             cat.AddObserver(new Dog());
             cat.AddObserver(new Parents());
             cat.AddObserver(new Baby());
             cat.AddObserver(new Thief());
             cat.Miao();
             Console.ReadKey();
         }
     }

Main

通过观察者模式,主题与观察者之间的依赖被转移到了接口之上,面对新的扩展,完全不用再去修改主题,当我们需要添加新的观察者,只需要实现IObserver这个接口就可以,当我们需要修改顺序的时候,只需要在上端改变添加的顺序就可以

观察者模式的类图:

观察者模式存在的3种角色:

1主题角色(Cat):被关注的对象

2抽象观察者角色(IObserver):具体观察者角色的抽象

3具体观察者角色(Dog,Parents,Baby,Thief):关注主题的对象,在主题状态改变后,作出响应

Csharp下更优选择

相比于上述使用观察者模式解决问题,在.Net里有更加优秀的解决方案,那就是委托事件

同样是上述这个问题,使用委托事件来解决,代码如下

     public class Cat
     {
         public event Action MiaoEvent;
         public void Miao()
         {
             Console.WriteLine("猫叫了..........");

             MiaoEvent.Invoke();
         }
     }

Subject

    public class Dog
     {
         public void Wang()
         {
             Console.WriteLine("狗汪了..........");
         }
     }

     public class Parents
     {
         public void Wake()
         {
             Console.WriteLine("大人醒了..........");
         }
     }

     public class Baby
     {
         public void Cry()
         {
             Console.WriteLine("婴儿哭了..........");
         }
     }

     public class Thief
     {
         public void Run()
         {
             Console.WriteLine("小偷跑了..........");
         }
     }

ObjectForAction

     class Program
     {
         static void Main(string[] args)
         {
             Cat cat = new Cat();
             cat.MiaoEvent += new Dog().Wang;
             cat.MiaoEvent += new Parents().Wake;
             cat.MiaoEvent += new Baby().Cry;
             cat.MiaoEvent += new Thief().Run;
             cat.Miao();
             Console.ReadKey();
         }
     }

Main

使用观察者模式,主题内部维护的是一堆观察者的抽象对象,使用事件的方式,主题内部维护的是一张方法列表

适用场景和优劣势

当存在一对多的依赖关系,且需要监听状态变化的时候,观察者模式是一个很好的解决方案,例如:服务订阅通知,警报监控等等

优势:

1隔离了对象之间的直接依赖,降低了程序的耦合度

2增加了程序的可读性,方便了维护和扩展

3不需要熟悉观察者的细节详情,只用实现接口就可以

劣势:

1增加了程序的复杂度,设计模式的通病

2观察者模式的效率是个问题,一个后续动作出现问题,会堵塞整个过程

出自:博客园-半路独行

原文地址:https://www.cnblogs.com/banluduxing/p/9279571.html

本文出自于http://www.cnblogs.com/banluduxing 转载请注明出处。