C#委托和事件实现观察者模式

需求背景

   猫叫触发一系列的动作或者说触发一系列事件，猫叫导致狗叫，小孩哭，Mom跑。

代码结构申明

    /// <summary>
    /// 接口类
    /// </summary>
    public interface IObeject
    {
        /// <summary>
        /// 提供该方法执行一系列继承自该接口的类行为
        /// </summary>
        void DoAction();
    }

    /// <summary>
    /// 狗类
    /// </summary>
    public class Dog : IObeject
    {
        public void DoAction()
        {
            this.Wang();
        }
        /// <summary>
        /// 狗叫
        /// </summary>
        public void Wang() {
            Console.WriteLine("狗叫了...");
        }
    }

    /// <summary>
    /// 孩子类
    /// </summary>
    public class Baby : IObeject
    {
        public void DoAction()
        {
            this.Cry();
        }
        /// <summary>
        /// 小孩吓哭了
        /// </summary>
        public void Cry() {
            Console.WriteLine("小孩吓哭了");
        }

    }

    /// <summary>
    /// Mom类
    /// </summary>
    public class Mom : IObeject
    {
        public void DoAction()
        {
            this.Run();
        }
        /// <summary>
        /// 妈妈跑
        /// </summary>
        public void Run() {
            Console.WriteLine("妈妈着急了，Mom Run...");
        }
    }

    /// <summary>
    /// 猫类
    /// </summary>
    public class Cat
    {
        /// <summary>
        /// Cat类依赖了多种类型，任何猫类依赖的类型变化都与猫有关，猫类甚至还要控制事件的执行顺序。
        /// 如果事件需要调整顺序，或者猫依赖的类发生变化都得修改猫类的代码，类与类之间的关系严重耦合。且职责不单一
        /// 实际上不该如此，猫就是猫，猫只负责Miao，猫只做自己的事，别的事与我无关，需求就是猫Miao了一声，触发一系列
        /// 动作，至于触发什么动作，与猫无关。
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("猫叫了一声...");
            new Dog().Wang();
            new Baby().Cry();
            new Mom().Run();
        }

        private IList<IObeject> _ObserverList = new List<IObeject>();

        public void AddObserver(IObeject obeserver) {
            this._ObserverList.Add(obeserver);
        }

        public void MiaoObserver() {

            foreach (var _obeserver in _ObserverList)
            {
                _obeserver?.DoAction();
            }
        }

        #region 使用委托
        public Action CatMiaoAction;

        public void MiaoDelegate() {

            this.CatMiaoAction?.Invoke();
        }
        #endregion

        #region 使用事件
        /// <summary>
        /// 什么是事件？事件是委托的一个实例，如Student的一个实例是张三，并且带有event关键字修饰，事件是一种更安全的特殊委托
        /// 只能在事件所在的类内部对其赋值和调用（invoke();),不能在外部对其赋值和调用，即使是子类。
        /// </summary>
        public event Action CatMiaoActionEvent;

        public void MiaoDelegateHandler()
        {
           //this.CatMiaoActionEvent = null;//编译可以通过
           this.CatMiaoActionEvent?.Invoke();//编译可以通过
        }
        #endregion
    }

    public class MiniCat : Cat
    {
        public void Do()
        {
            //this.CatMiaoActionEvent = null;//即使是子类，编译不通过,不能赋值
            //this.CatMiaoActionEvent?.invoke();//即使是子类，编译不通过，不能调用
        }
    }

    static void Main(string[] args)
        {
            {
                new Cat().Miao();
            }
            {
                //去除了猫类对其它类的依赖，把依赖通过抽象转移到外部，事件的触发逻辑交给调用者，与猫
                //无关，猫作为事件发布者，这是一种观察者模式的运用
                Cat cat = new Cat();
                cat.AddObserver(new Dog());
                cat.AddObserver(new Baby());
                cat.AddObserver(new Mom());
                cat.MiaoObserver();
                Console.WriteLine("**********");
            }
            {
                //使用委托和事件的方式解决该问题,去除了Cat的依赖，Cat稳定了,还可以有多个Cat.CatMiaoAction的实例
                Cat cat = new Cat();
                cat.CatMiaoAction += new Dog().Wang;
                cat.CatMiaoAction += new Baby().Cry;
                cat.CatMiaoAction += new Mom().Run;
                cat.MiaoDelegate();
                Console.WriteLine("**********");
            }
            {
                //使用委托和事件的方式解决该问题,去除了Cat的依赖，Cat稳定了,还可以有多个Cat.CatMiaoActionEvent的实例
                Cat cat = new Cat();
                cat.CatMiaoActionEvent += new Dog().Wang;
                cat.CatMiaoActionEvent += new Baby().Cry;
                cat.CatMiaoActionEvent += new Mom().Run;
                cat.MiaoDelegateHandler();
                Console.WriteLine("**********");
            }
            Console.ReadLine();
        }