委托的应用之事件

前言

　　上一个章节介绍了委托，这里我们再通过一个例子继续巩固一下委托并引入事件  。

　　为了便于理解，这里还是引入一个很老的例子:

      因为一只猫叫了一声 接着老鼠被吓跑 小孩哭也了起来 最后妈妈也被吵醒。

      下面用代码来实现这些功能

    /// <summary>
    /// 猫类
    /// </summary>
    public class Cat
    {      
        /// <summary>
        /// 猫叫的方法
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("猫喵了一声");

            new Mouse().Run();
            new Baby().Cry();
            new Mother().Awake();
        }
    }


    /// <summary>
    /// 老鼠类
    /// </summary>
    public class Mouse
    {
        /// <summary>
        /// 老鼠跑的方法
        /// </summary>
        public void Run()
        {
            Console.WriteLine("老鼠开始跑");
        }
    }

   /// <summary>
    /// 小孩类
    /// </summary>
    public class Baby
    {
        /// <summary>
        /// 小孩哭的方法
        /// </summary>
        public void Cry()
        {
            Console.WriteLine("婴儿哭了起来");
        }
    }

    /// <summary>
    /// 妈妈类
    /// </summary>
    public class Mother
    {
        /// <summary>
        /// 妈妈醒的方法
        /// </summary>
        public void Awake()
        {
            Console.WriteLine("妈妈被吵醒了");
        }
    }

   class Program
    {
        static void Main(string[] args)
        {
            {
                //直接调用
                new Cat().Miao();
            }          
            Console.ReadLine();
        }
    }

　　代码写完了，功能完成了 。

　　那么问题还是那个问题：耦合，依赖，不扩展，增加类的动作或者调整顺序都会导致Cat类被修改。

　　为解决这一问题 还是用前面用的委托（上一章就是学习的委托的接解藕功能），

　　代码如下：

 

　　在Cat类声明一个委托 

   //这里定义一个委托
    public delegate void MiaoHandel();

    /// <summary>
    /// 猫类
    /// </summary>
    public class Cat
    {      
        /// <summary>
        /// 猫叫的方法
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("猫喵了一声");
        }
    }

　　外面再给委托添加后和删除方法，还可以任意调整顺序且不用修改Cat类。

class Program
    {
        static void Main(string[] args)
        {
            {
                //直接调用
                new Cat().Miao();
            }
            Console.WriteLine("--------------------------------");
            {
                //用委托来调用
              MiaoHandel miaoHandel=new MiaoHandel(new Cat().Miao);
              miaoHandel += new Mouse().Run;
              miaoHandel += new Baby().Cry;
              miaoHandel += new Mother().Awake;
              //还可以通过-=来删除方法
              miaoHandel -= new Mother().Awake;
              miaoHandel.Invoke();
            }
            Console.ReadLine();
        }
    }

 

　　说到这儿，那么到底什么是事件呢？

　　其实前面我讲了委托是一个类，那么事件就是委托的一个实例，加了一个event关键字。

　　那要说委托与事件的区别。本质上就是类跟实例的区别了。

　　来我们还是来看看代码

 

　　先在Cat类定义一个事件

   //这里定义一个委托
    public delegate void MiaoHandel();

    /// <summary>
    /// 猫类
    /// </summary>
    public class Cat
    {      
        /// <summary>
        /// 猫叫的方法
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("猫喵了一声");
        }

        public event MiaoHandel MiaoHandelEvent;
    }

 

主程序里面就用我们自己定义的委托的实例（事件）来调用

class Program
    {
        static void Main(string[] args)
        {
            {
                //直接调用
                new Cat().Miao();
            }
            Console.WriteLine("--------------------------------");
            {
                //用委托来调用
                Cat cat = new Cat();
                cat.MiaoHandelEvent = new MiaoHandel(new Cat().Miao); //报错了：这里不能直接赋值
                cat.MiaoHandelEvent += new Mouse().Run;
                cat.MiaoHandelEvent += new Baby().Cry;
                cat.MiaoHandelEvent += new Mother().Awake;
                //还可以通过-=来删除方法
                cat.MiaoHandelEvent -= new Mother().Awake;
                cat.MiaoHandelEvent.Invoke(); //报错了：这里不能直接赋
            }
            Console.ReadLine();
        }
    }

　　改成事件之后 ，我们会发现 事件是不能被赋值和调用的，这样做的好处就是 出于安全性的考虑，可以控制权限，外面不能赋值/调用。

　　那么要使用事件就必须在这个事件的发起者内部定义调用的方法。再来看看 修改之后最终的代码

　　

　　猫类的方法

namespace DelegateEventDemo
{
    //这里定义一个委托
    public delegate void MiaoHandel();

    /// <summary>
    /// 猫类
    /// </summary>
    public class Cat
    {      
        /// <summary>
        /// 猫叫的方法
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("猫喵了一声");
        }

        public event MiaoHandel MiaoHandelEvent;

        /// <summary>
        /// 事件的调用方法
        /// </summary>
        public void MiaoHandelEventInvoke()
        {
            if (this.MiaoHandelEvent != null)
            {
                MiaoHandelEvent.Invoke();
            }
        }
    }
}

　　最终调用

class Program
    {
        static void Main(string[] args)
        {
            {
                //直接调用
                new Cat().Miao();
            }
            Console.WriteLine("--------------------------------");
            {
                //用委托来调用
                Cat cat = new Cat();
                cat.MiaoHandelEvent += new Cat().Miao; 
                cat.MiaoHandelEvent += new Mouse().Run;
                cat.MiaoHandelEvent += new Baby().Cry;
                cat.MiaoHandelEvent += new Mother().Awake;

                cat.MiaoHandelEventInvoke(); 
            }
            Console.ReadLine();
        }
    }

 

 总结

       委托与事件的区别：

　　1. 委托是一个类型，事件就是委托的一个具体实例，加上一个event关键字

　　2. 委托可以直接赋值和调用。而事件不能直接被赋值和调用， 这是出于安全性的考虑。