C#程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。

C#程序设计: 猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。

要求：  

1.要有联动性，老鼠和主人的行为是被动的。

2.考虑可扩展性，猫的叫声可能引起其他联动效应。

 要点：1. 联动效果，运行代码只要执行Cat.Cryed()方法。

　　    2. 对老鼠和主人进行抽象

看到这个程序设计题目，第一反应是用事件来解决，猫叫触发了事件，引起了老鼠的逃跑，老鼠逃跑又触发了事件导致主人被惊醒，或者是猫叫引起了老鼠逃跑、人醒。所以按照这个思路，做出了如下的解答。

    第一种解决方案用事件来解决：是多级的联动：即：猫叫-》老鼠跑-》人醒

    第二种解决方案采用观察者模式：猫叫-》老鼠跑；猫叫-》人醒

我么能事件来一步一步来实现： 将要执行的老鼠逃跑，和主人惊醒的行为注册到事件中，猫叫之后引发事件的执行！

1.首先声明一个委托，因为是由猫叫引发的事件执行，所有事件声明在猫类中

    public delegate void Delegate();
    public class Cat
    {
        public event Delegate Eventhandler;

        public void FireAway()
        {
            if (this.Eventhandler != null)
            {
                this.Eventhandler();
            }
        }
    }

 2.下面写（老鼠，主人），对其类实例化时，将要执行的行为注册到事件中

    public class Master
    {
        public Master(Cat cat)
        {
            cat.Eventhandler += new Delegate(Action);
        }
        public void Action()
        {
            Console.WriteLine("主人听见了！");
        }
    }
    public class Mouse
    {
        public Mouse(Cat cat)
        {
            cat.Eventhandler += new Delegate(Action);
        }
        public void Action()
        {
            Console.WriteLine("老鼠听见了，逃跑！");
        }
    }

3.执行，执行cat的FireAwayAndWakeup方法，内部执行已注册到事件的方法

            Cat cat = new Cat();
            Mouse mouse = new Mouse(cat);
            Master master = new Master(cat);
            cat.FireAway();

优化点一：虽然已经实现但是考虑到可扩展性，这类中都是在构造函数中的注册事件，并且有一个执行方法，那么如果扩展其他功能例如：邻居听到了......我们需要写相同的代码，所以我们有必要用到观察者（猫叫一后，所引发的的对象）提供一个父类或者是一个接口来统一标准，但是因为观察者都是在构造函数中进行事件的注册，而注册到事件中的方法所做的事件不同（例：老鼠逃跑、主人等），所以我们来创建一个父类（既有接口的功能，也有具体的事件），抽象类,又它来作为观察者的父类

   public abstract class Observer
    {
        public Observer(Cat cat)
        {
            cat.Eventhandler += new Delegate(Action);
        }
        public abstract void Action();
    }

类的修改

    public class Master:Observer
    {
        public Master(Cat cat):base(cat)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {
            
        }
        public override void Action()
        {
            Console.WriteLine("主人听见了！");
        }
    }
    public class Mouse:Observer
    {
        public Mouse(Cat cat) : base(cat)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {

        }
        public override void Action()
        {
            Console.WriteLine("老鼠听见了，跑了！！");
        }
    } 

 优化点二：我们再对第2部分进行改进，这里是由 猫叫 引发的一系列的行为，但是如果我们之后又想添加 狗叫 引发这些行为的话，那么就需要再重写第2部分的那些代码，本着可扩展的目的，我们为这些引发行为的 引发者(猫、狗) 添加一个父类，父类中去实现引发事件的执行，而其派生类(阿猫、阿狗)，只负责去调用其父类中的方法即可.

 

    public abstract class Cry
    {
        public event Delegate Eventhandler;
        public void FireAway()
        {
            if (this.Eventhandler!=null)
            {
                this.Eventhandler();

            }
        }
    }

 

    public class Master:Observer
    {
        public Master(Cry sub) :base(sub)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {
            
        }
        public override void Action()
        {
            Console.WriteLine("主人听见了！");
        }
    }
    public class Mouse:Observer
    {
        public Mouse(Cry sub) : base(sub)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {

        }
        public override void Action()
        {
            Console.WriteLine("老鼠听见了，跑了！！");
        }
    }

            Cat cat = new Cat();
            Mouse mouse = new Mouse(cat);
            Master master = new Master(cat);
            cat.Cry();

            Dog dog = new Dog();
            Mouse dog_mouse = new Mouse(dog);
            Master dog_master = new Master(dog);
            dog.Cry();

            Console.ReadKey();

  值得注意的是，观察者 的构造函数中的参数类型，要改为引发者的父类：Subject 。因为不止可以将引发的行为(老鼠逃跑、主人醒等)添加到猫引发的事件中，还可以将其添加到狗引发的事件中。

所以整个部分应该为：

    public abstract class Cry
    {
        public event Delegate Eventhandler;
        public void FireAway()
        {
            if (this.Eventhandler!=null)
            {
                this.Eventhandler();

            }
        }
    }

   public abstract class Observer
    {
        public Observer(Cry sub)
        {
            sub.Eventhandler += new Delegate(Action);
        }
        public abstract void Action();
    }

    public class Master:Observer
    {
        public Master(Cry sub) :base(sub)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {
            
        }
        public override void Action()
        {
            Console.WriteLine("主人听见了！");
        }
    }
    public class Mouse:Observer
    {
        public Mouse(Cry sub) : base(sub)//执行父类中的构造函数，并且将此派生类中的方法在父类的构造函数中注册到事件中
        {

        }
        public override void Action()
        {
            Console.WriteLine("老鼠听见了，跑了！！");
        }
    }

    public class Cat : Cry
    {
        public void Cry()
        {
            this.FireAway();
        }

    }
    public class Dog : Cry
    {
        public void Cry()
        {
            this.FireAway();
        }
    }
    public delegate void Delegate();

            Cat cat = new Cat();
            Mouse mouse = new Mouse(cat);
            Master master = new Master(cat);
            cat.Cry();

            Dog dog = new Dog();
            Mouse dog_mouse = new Mouse(dog);
            Master dog_master = new Master(dog);
            dog.Cry();

            Console.ReadKey();

 

 

 详细：https://www.cnblogs.com/wupeiqi/p/3155254.html