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("小偷跑了..........");
        }
    }

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

 

代码分析

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

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

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

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

 

观察者模式

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

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

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

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

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

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

    /// <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();
            }
        }
    }

    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();
        }
    }

    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();
        }
    }

通过观察者模式,主题与观察者之间的依赖被转移到了接口之上,面对新的扩展,完全不用再去修改主题,当我们需要添加新的观察者,只需要实现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();
        }
    }

   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("小偷跑了..........");
        }
    }

    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();
        }
    }

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

 

适用场景和优劣势

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

优势:

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

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

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

劣势:

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

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

 

出自:博客园-半路独行

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

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