C#forUnity快速入门(连载15)_C#委托与事件

C# for Unity编程语言快速入门教程(连载15)_C#委托与事件

    C#的委托(delegate)与事件(event)  其实不是一个容易理解的技术，而且很多C#书籍作者还经常把它与“观察者设计模式”（Observer模式）放在一起进行讨论（注：因为委托与事件是“Observer”设计模式的一种很好的实现方式），其实这就进一步增加了对于C#初学者的学习难度。

  所以笔者打破常规，先从讲故事的方式，先来介绍"委托”。

案例故事：“老板来啦！”
       2007年是中国股市非常火热的一年，某公司办公室每个员工都在热心“炒股”，为了防止老板看见，所以大家让“办公室前台”小张来注意老板；每当老板进入办公室的时候，则小张就给每个好友QQ通知，“老板来啦！” 

以上案例，编写如下代码：

    class Program
    {
        public void InformMrZhangSan(string name)
        {
            Console.WriteLine("{0},老板来了，张三，请关闭电脑", name);
        }

        public void InformMrLisi(string name)
        {
            Console.WriteLine("{0},老板来了，李四，请关闭电脑", name);
        }

        public void InformMrWangWu(string name)
        {
            Console.WriteLine("{0},老板来了，王五，请关闭电脑", name);
        }

        /// <summary>
        /// （前台）小张发信息
        /// </summary>
        public void MrZhangSendInfo()
        {
            InformMrZhangSan("我是前台小张");
            InformMrLisi("我是前台小张");
            InformMrWangWu("我是前台小张");
        }

        static void Main1(string[] args)
        {
            Program obj = new Program();
            obj.MrZhangSendInfo();
        }
    }

    以上代码，就是一个典型的同步代码实现，也就是调用一个类型的方法，会即刻出现该方法执行的结果。相信大家很好理解以上代码。

   问题来了，此时如果公司有很多员工，都要求“前台小张”来发QQ（单独）通知给他。当然还要想到，可能公司还会有新的员工加入“炒股”的队伍，也要求“前台小张”来进行“提醒”服务，这如何处理呢？

  我们先考虑案例故事中的解决方案： 大家一定能够想到，其实很简单，可以建立一个“QQ提醒群”，需要提醒的公司员工，可以提前加入到这个群中。当老板进入办公室的时候，前台小张只需要在Q群里发布一条消息：“老板来了，注意啦！”即可，这样无论公司员工不断加入，还有有人离开这个群，对于小张来说是不受任何影响的。

  我们按照以上的思路，重写以上类，代码如下所示：

   //定义委托： 通知信息
    public delegate void InformInfoHandler(string name);

    //定义类
    class UseDeledate
    {
        public void InformMrZhangSan(string name)
        {
            Console.WriteLine("{0},老板来了，张三，请关闭电脑", name);
        }

        public void InformMrLisi(string name)
        {
            Console.WriteLine("{0},老板来了，李四，请关闭电脑", name);
        }

        public void InformMrWangWu(string name)
        {
            Console.WriteLine("{0},老板来了，王五，请关闭电脑", name);
        }

        //新来的同事
        public void InformMrNewComer(string name)
        {
            Console.WriteLine("{0},老板来了，新来的同事，请关闭电脑", name);
        }


        /// <summary>
        /// 通知所有人
        /// </summary>
        /// <param name="name"></param>
        /// <param name="informInfoDelegate"></param>
        public void InformAll(string name,InformInfoHandler informInfoDelegate)
        {
            informInfoDelegate(name);
        }


        /// <summary>
        /// （前台）小张发信息
        /// </summary>
        public void MrZhangSendInfo()
        {
            //定义委托（很类似“定义类”）
            InformInfoHandler myInform = new InformInfoHandler(InformMrZhangSan);
            myInform += new InformInfoHandler(InformMrLisi);
            myInform += new InformInfoHandler(InformMrWangWu);
            myInform += new InformInfoHandler(InformMrNewComer);

            InformAll("我的前台小张",myInform);
        }

        static void Main(string[] args)
        {
            UseDeledate obj = new UseDeledate();
            obj.MrZhangSendInfo();
        }
    }

  在以上示例代码中，我们先定义了一个委托：public delegate void InformInfoHandler(string name); 这个委托的类型，必须与需要注册的方法“签名”（方法的参数列表与返回类型）一致。然后我们定义类：“UseDeledate” ，在这个类中，方法MrZhangSendInfo()就是负责方法的“注册”，这里就相当于，在小张通知Q群前，需要让需要的公司员工提前“入群”。

   方法 InformAll() 的方法列表中，我们引入了委托类型: InformInfoHandler ,通过这个委托，来间接调用注册的所有方法(一共4个)。这样无论调用的方法是一个还是很多，调用方法只是用 “informInfoDelegate(name); ” 这个委托即可完成任务，实现了“调用方”与（实现功能）“方法体”本身的解耦和。

 以上代码的写法主要是考虑与故事的配合，在这给出更加一般的委托定义编写方式示例：

   //定义委托（通知信息）
    public delegate void InformInfoHandler(string name);

    class UseDeletage2
    {
        //声明委托类型
        InformInfoHandler myInform;

        public UseDeletage2()
        {
            //委托注册（）
            myInform = new InformInfoHandler(InformMrZhangSan);
            myInform += new InformInfoHandler(InformMrLisi);
            myInform += new InformInfoHandler(InformMrWangWu);
            myInform += new InformInfoHandler(InformMrNewComer);

            ////委托取消注册
            //myInform -= new InformInfoHandler(InformMrWangWu);

            //直接用“=”赋值符号，则仅最后注册的方法有效。
            //myInform = new InformInfoHandler(InformMrZhangSan);
            //myInform = new InformInfoHandler(InformMrLisi);
            //myInform = new InformInfoHandler(InformMrWangWu);
            //myInform = new InformInfoHandler(InformMrNewComer);
        }


        public void InformMrZhangSan(string name)
        {
            Console.WriteLine("{0},老板来了，张三，请关闭电脑", name);
        }
        public void InformMrLisi(string name)
        {
            Console.WriteLine("{0},老板来了，李四，请关闭电脑", name);
        }
        public void InformMrWangWu(string name)
        {
            Console.WriteLine("{0},老板来了，王五，请关闭电脑", name);
        }
        //新来的同事
        public void InformMrNewComer(string name)
        {
            Console.WriteLine("{0},老板来了，新来的同事，请关闭电脑", name);
        }


        /// <summary>
        /// 通知所有人（此步骤可以省略）
        /// </summary>
        /// <param name="name"></param>
        /// <param name="informInfoDelegate"></param>
        //public void InformAll(string name, InformInfoHandler informInfoDelegate)
        //{
        //    informInfoDelegate(name);
        //}


        /// <summary>
        /// （前台）小张发信息
        /// </summary>
        public void MrZhangSendInfo()
        {
            //InformAll("我的前台小张", myInform); //省略
            myInform("我是前台的小张");
        }

        static void Main1(string[] args)        
        {
            Console.WriteLine("UseDeletage2 测试");
            UseDeletage2 obj = new UseDeletage2();
            obj.MrZhangSendInfo();
        }
    }

委托定义方式可以总结如下四个步骤。
A)  定义委托
B) 声明委托实例。
C) 委托注册（注册方法）
D) 调用委托

现在总结委托的一些普遍规则：

规则1： 委托本质上就是一个“类”，能定义类的地方，都可以定义委托。
       （可以通过反编译软件，进行查看证明，委托就是继承了 [mscorlib]System.MulticastDelegate 的特殊类）

规则2： 使用委托技术，可以实现在“在方法的参数中传方法”。
        即： 把一个方法作为参数，在另一个方法中进行调用。
        好处是： 大大减少程序中逻辑判断的分支。
                     
规则3： 多播委托（“委托链”）:  委托可以通过不断的进行“注册方法”,实现一次性调用多个方法。   

规则4：在方法中调用委托，比方法中直接调用方法的好处是:
            可以在不修改调用方法的前提下，不断的增加业务功能。
            以此可以更加灵活的处理逻辑，减少逻辑判断。

规则5:  委托技术可以实现“调用方”与“实现方”的解耦合。


规则6： 可以通过+= 与-= 来给“多播委托”（委托链），来
              动态的添加注册方法与取消注册方法。
        
规则7： 直接用“=”赋值符号，则仅最后注册的方法有效。
              则就不是“多播委托”（或者说“委托链”）了，可以起到“阻止”的作用。
 
规则8： 委托本质就是方法的地址。（类似C++ 语言中的“函数指针”）

现在给出一个“事件”的示例，然后总结一下委托与事件的区别：

    class UseEvent
    {
        //声明委托类型
        //InformInfoHandler myInform;

        //声明事件
        public event InformInfoHandler eveMyInform;

        public UseEvent()
        {
            //事件的注册（）
            //eveMyInform += new InformInfoHandler(InformMrZhangSan);
            //eveMyInform += new InformInfoHandler(InformMrLisi);
            //eveMyInform += new InformInfoHandler(InformMrWangWu);
            //eveMyInform += new InformInfoHandler(InformMrNewComer);

            //简化写法
            eveMyInform += InformMrZhangSan;
            eveMyInform += InformMrLisi;
            eveMyInform += InformMrWangWu;
            eveMyInform += InformMrNewComer;
        }

        public void InformMrZhangSan(string name)
        {
            Console.WriteLine("{0},老板来了，张三，请关闭电脑", name);
        }
        public void InformMrLisi(string name)
        {
            Console.WriteLine("{0},老板来了，李四，请关闭电脑", name);
        }
        public void InformMrWangWu(string name)
        {
            Console.WriteLine("{0},老板来了，王五，请关闭电脑", name);
        }
        //新来的同事
        public void InformMrNewComer(string name)
        {
            Console.WriteLine("{0},老板来了，新来的同事，请关闭电脑", name);
        }

        /// <summary>
        /// （前台）小张发信息
        /// </summary>
        public void MrZhangSendInfo()
        {
            eveMyInform("我是前台的小张");
        }

        static void Main1(string[] args)
        {
            Console.WriteLine("UseEvent 测试");
            UseEvent obj = new UseEvent();
            obj.MrZhangSendInfo();
        }
    }

按照以上示例，我们总结“委托”与“事件"的区别：
  A) “事件”本质上就是委托的一个实例
  B)  委托可以定义在类的外部，事件只能定义在类的内部。

    以上代码是事件“调用方”与“功能实现方”都定义在了同一个类中，是不具备“实战”价值的，所以笔者给出如下在商业项目中应用的示例，供大家参考：

    /// <summary>
    /// 委托： 通知信息
    /// </summary>
    /// <param name="name"></param>
    public delegate void InformInfoHandler(string name);

    //调用方

    class InvokeClass
    {
        //声明事件
        public static event InformInfoHandler eveMyInform;

        /// <summary>
        /// 显示通知信息
        /// </summary>
        public void DisplayInformInfo()
        {
            if (eveMyInform!=null)
            {
                //eveMyInform("我是前台");
                eveMyInform.Invoke("我是前台");
            }
        }

    }
 

    //业务功能实现方，以及“事件注册” 

    public class RegisterClass
    {
        public RegisterClass()
        {
            InvokeClass.eveMyInform += InfomrZhangSan;
            InvokeClass.eveMyInform += InfomrLisi;
        }

        void InfomrZhangSan(string name)
        {
            Console.WriteLine("{0},张三，上午好",name);
        }

        void InfomrLisi(string name)

        {
            Console.WriteLine("{0},李四，下午好", name);
        }
    }
 

    //测试类 

    class TestClass
    {
        /// <summary>
        /// 测试方法
        /// </summary>
        public static void Main()
        {
            //注册事件
            new RegisterClass();

            //调用方
            InvokeClass obj = new InvokeClass();
            obj.DisplayInformInfo();

        }
    }

    好了，以上代码大家如果可以看懂，就可以认为基本“懂”了委托与事件的基本使用，现在我们再引申性总结一下：

什么是“观察者模式”（Observer）

   观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

  这个委托与事件，笔者引申一点，帮助大家进一步思考：

  我们在开发一个软件系统（游戏项目）时，常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。例如: 我们游戏开发中，击中一架敌机，则屏幕UI的相应分数，要更新数值。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，并且这些低耦合的对象之间需要维持行动协调一致，保证很好的协作性。这样“观察者模式”是满足这一要求的最佳设计方案之一。