第九节：委托和事件(1)(委托的发展历史、插件式编程、多播委托)

 一. 委托的发展历史和基本用法

　　说起委托，每个人可能都会对他有不同的理解，结合实战中委托的使用，我对其理解是：委托和类一样，是用户的一个自定义类型，委托可以有参数、有返回值，委托的关键字是delegate，委托是方法的抽象，有了委托的存在，使得方法可以作为参数传递给另一个方法，同时调用委托的时候，委托所包含的所有方法都会被实现。

　　委托的写法由繁琐→简洁，经历了好多过程，大致概括为：new实例化传递方法→直接等于方法名→new实例化中传递匿名方法→省略匿名方法关键字→可以去掉大括号和分号 等等。

　　代码如下：

       

 public class MyDelegate
    {
        //1. 委托的声明
        public delegate void NoReturnNoPara();
        public delegate int WithReturnNoPara();
        public delegate void NoReturnWithPara(int id, string name);
        public delegate MyDelegate WithReturnWithPara(DateTime time);


        //2. 委托的使用(在show方法中调用)
        public void Show()
        {
            //以“有参无返回值委托”为例,介绍委托的各种用法
            //2.1 用法一
            {
                NoReturnWithPara methord = new NoReturnWithPara(this.Test1);
                methord.Invoke(1, "唐马儒1");
            }
            //2.2 用法二
            {
                NoReturnWithPara methord = this.Test1;
                methord.Invoke(2, "唐马儒2");
            }
            //2.3 用法三 DotNet 2.0 时代
            {
                NoReturnWithPara methord = new NoReturnWithPara
                    (
                    delegate(int id, string name)
                    {
                        Console.WriteLine("{0} {1}", id, name);
                    }
                    );
                methord.Invoke(3, "唐马儒3");
            }
            //2.4 用法四 DotNet 3.0 时代
            {
                NoReturnWithPara methord = new NoReturnWithPara
                    (
                        (int id, string name) =>
                        {
                            Console.WriteLine("{0} {1}", id, name);
                        }
                    );
                methord.Invoke(4, "唐马儒4");
            }
            //2.5 用法五 委托约束
            {
                NoReturnWithPara methord = new NoReturnWithPara
                    (
                        (id,name) =>
                        {
                            Console.WriteLine("{0} {1}", id, name);
                        }
                    );
                methord.Invoke(5, "唐马儒5");
            }
            //2.6 用法六 （如果方法体只有一行，可以去掉大括号和分号）
            {
                NoReturnWithPara methord = new NoReturnWithPara((id, name) => Console.WriteLine("{0} {1}", id, name));
                methord.Invoke(6, "唐马儒6");
            }
            //2.7 用法七
            {
                NoReturnWithPara methord = (id, name) => Console.WriteLine("{0} {1}", id, name);
                methord.Invoke(7, "唐马儒7");
                methord(7, "唐马儒7");
            }
            //2.8 用法八
            {
                //Func<int, bool> methord = (x) =>
                // {
                //     return x > 6;
                // };
                //等价于(原理，当只有一个参数的时候，可以省略参数的小括号，当方法体只有一行的时候，可以省略大括号和分号，即lambda形式)
                Func<int, bool> methord = x => x > 6;
                Console.WriteLine(methord.Invoke(8));
            }

        }
        private void Test1(int id, string name)
        {
            Console.WriteLine("{0} {1}", id, name);
        }

        private void Test2()
        {
            Console.WriteLine("DoNothing");
        }

        private void Test3()
        {
            Console.WriteLine("DoNothing");
        }
    }

二. 解耦、插件式编程

　　1. 背景：有一个CarFactory工厂类，可以建造自然吸气发动机、涡轮增压发动机、电动发动机，至于要建造哪个发动机，有多种处理方案。　

　  方案(一)：通过传递不同的参数来建造不同的发动机

　   　　原理：传递一个参数,根据参数类型来执行不同的逻辑
　　　　缺点：如果增加新的发动机类型,需要修改BuildEngine方法中的内部逻辑,不符合开闭原则

　　代码如下：

  /// <summary>
    /// 这里建一个Car工厂,用来建造三种不同类型的发动机
    /// </summary>
    public class CarFactory
    {
        /// <summary>
        /// 方案一：通过传递不同的参数来建造不同的发动机
        /// 原理：传递一个参数,根据参数类型来执行不同的逻辑
        /// 缺点：如果增加新的发动机类型,需要修改BuildEngine方法中的内部逻辑,不符合开闭原则
        /// </summary>
        /// <param name="type">参数类型</param>
        public static void BuildEngine(EngineType type)
        {
            if (type == EngineType.NaturalInspiration)
            {
                Console.WriteLine("建造自然吸气发动机");
            }
            else if (type == EngineType.Turbo)
            {
                Console.WriteLine("建造涡轮增压发动机");
            }
            else if (type == EngineType.Electric)
            {
                Console.WriteLine("建造电动发动机");
            }
        }

    /// <summary>
    /// 发动机类型的枚举类
    /// </summary>
    public enum EngineType
    {
        NaturalInspiration = 0,   //自然吸气
        Turbo = 1,                //涡轮增压
        Electric = 2              //电动
    }
}

　　调用：

  //1.传统的方式,通过参数类型来区分
 Console.WriteLine("--------------------------1.传统的方式,通过参数类型来区分------------------------------------");
CarFactory.BuildEngine(EngineType.NaturalInspiration);
CarFactory.BuildEngine(EngineType.Turbo);
CarFactory.BuildEngine(EngineType.Electric);

　　结果：

　　方案(二)：通过传递委托来建造不同的发动机

　　　　原理：传递一个逻辑给我,我去执行

　　　　优点：如果增加新的发动机,只需要单独新增对应建造发动机的方法即可,不需要改变BuildEngine2的内部逻辑,符合开闭原则

 　 代码如下：

  public class CarFactory
    {
        /// <summary>
        /// 方案二：通过传递委托来建造不同的发动机
        /// 原理：传递一个逻辑给我,我去执行
        /// 优点：如果增加新的发动机,只需要单独新增对应建造发动机的方法即可,不需要改变BuildEngine2的内部逻辑,符合开闭原则
        /// </summary>
        public static void BuildEngine2(BuildEngineDel be)
        {
            be.Invoke();
        }
        //声明一个无参数的委托
        public delegate void BuildEngineDel();
        //下面三个是建造不同发动机的方法
        public static void BuildNatural()
        {
            Console.WriteLine("建造自然吸气发动机");
        }
        public static void BuildTurbo()
        {
            Console.WriteLine("建造涡轮增压发动机");
        }
        public static void BulidElectric()
        {
            Console.WriteLine("建造电动发动机");
        }

    }
}

　　调用：

    //2.将委托当做参数,进行解耦,实现插件式编程(案例一)
    Console.WriteLine("--------------------------2.将委托当做参数,进行解耦,实现插件式编程(案例一)------------------------------------");
     //将方法赋给委托,将委托当做参数传递给新方法
    CarFactory.BuildEngineDel be1 = CarFactory.BuildNatural;
    CarFactory.BuildEngine2(be1);
    CarFactory.BuildEngineDel be2 = CarFactory.BuildTurbo;
    CarFactory.BuildEngine2(be2);
    CarFactory.BuildEngineDel be3 = CarFactory.BulidElectric;
    CarFactory.BuildEngine2(be3);

　　结果：

 

　　2. 背景:现在有一个类，该类要实现对一个int类型的数组中的每个数进行加倍、平方、立方,并输出　

　　传统解决方案一：在该类中声明多个方法，分别是加倍、平方、立方的方法

　  传统解决方案二：在该类中声明一个万能方法，通过传递不同的参数类型来区分是执行加倍还是平方或者立方操作

　  方案三：声明一个万能方法，传递一个委托进来，相当于传递了一个业务逻辑进行，在该方法里只需要执行即可

　  代码如下：

 public class Calculator
    {
        //解决方案三：声明一个万能方法，传递一个委托进来，相当于传递了一个业务逻辑进行，在该方法里只需要执行即可
        /// <summary>
        /// 万能方法
        /// </summary>
        /// <param name="arrs">int类型的数组 </param>
        /// <param name="mydel">系统自带的委托（也可以自定义委托），<int,int>代表：参数和返回值均为int类型</param>
        public static void MySpecMethord(int[] arrs, Func<int,int> mydel)
        {
            for (int i = 0; i < arrs.Length; i++)
            {
                arrs[i] = mydel(arrs[i]);
                //arrs[i] = mydel.Invoke(arrs[i]);  //等价于上面那句
                Console.WriteLine(arrs[i]);
            }
        }

    }

　  三种调用形式：声明Func委托把方法赋值给它、直接把方法名传递进去、传递lambda方法。

   Console.WriteLine("--------------------------3.将委托当做参数,进行解耦,实现插件式编程(案例二)------------------------------------");
    int[] arr = { 1, 2, 3, 4, 5 };
    //调用形式一：
   Console.WriteLine("--------------------------调用形式一------------------------------------");
   Func<int, int> mydel = t1;
   Calculator.MySpecMethord(arr, mydel);
    //调用形式二：
    Console.WriteLine("--------------------------调用形式二------------------------------------");
    Calculator.MySpecMethord(arr, t2);
   //调用形式三：
    Console.WriteLine("--------------------------调用形式三------------------------------------");
    Calculator.MySpecMethord(arr, x => x * 2);
        /// <summary>
        /// 加倍方法
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public static int t1(int x)
        {
            return x * 2;
        }
        /// <summary>
        /// 乘方方法
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public static int t2(int x)
        {
            return x * x;
        }
        /// <summary>
        /// 立方方法
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public static int t3(int x)
        {
            return x * x * x;
        }

 　　结果：

 三. 多播委托

  1. 含义：所有的委托的实例都有多播的功能,自定义委托和内置委托都有，可以通过+=和-=给委托增加和删掉不同的方法。

　  下面的代码中分别介绍四个不同类别的方法赋值给普通委托和多播委托的形式。

 public class myMultiDelegate
    {
        //自定义一个没有参数没有返回值的委托
        public delegate void NoReturnNoPara();

        /// <summary>
        /// 测试委托常规用法
        /// </summary>
        public void show1()
        {
            Student student = new Student();
            //委托的普通用法,分别调用当前类的实例方法、当前类的静态方法、其他类的实例方法、其他类的静态方法
            //声明4个委托
            NoReturnNoPara n1 = this.DoNothing;  //调用当前类的实例方法
            NoReturnNoPara n2 = myMultiDelegate.DoNothingStatic; //调用当前类的静态方法
            NoReturnNoPara n3 = student.Study;
            NoReturnNoPara n4 = Student.StudyAdvanced;
            
            //执行
            n1.Invoke();
            n2.Invoke();
            n3.Invoke();
            n4.Invoke();
        }
        /// <summary>
        /// 测试多播委托的用法
        /// </summary>
        public void show2()
        {
            //所有的委托的实例都有多播的功能,自定义委托和内置委托都有
            NoReturnNoPara n1 = this.DoNothing;
            //+=就是把多个方法按顺序排成列表，invoke时按顺序执行
            n1 += myMultiDelegate.DoNothingStatic;
            n1 += Student.StudyAdvanced;
            n1 += this.DoNothing;
            n1 += this.DoNothing;
            n1 += this.DoNothing;
            n1 += this.DoNothing;
            //-=就是从这个实例上，从后往前挨个匹配，找到第一个完全吻合的移除掉，且只移除一个，找不到不异常
            //注意，对于委托，+= 和 -= 对null是不会报错的
            n1 -= this.DoNothing;  
            n1.Invoke();
        }


        #region 两个供委托调用的测试方法
        private void DoNothing()
        {
            Console.WriteLine("当前类中的实例方法");
        }
        private static void DoNothingStatic()
        {
            Console.WriteLine("当前类中的静态方法");
        }
        #endregion
    }

2. 多播委托的实际使用场景。

 实际注册业务场景：先查询账号是否存在(如果不存在)→向表1中插入信息→向表2中插入信息。。。。，随着业务新需求的变更,注册时需要向表3中插入数据, 过了一段时间，需求又变了，不需要向表2中添加数据了。

  下述代码是一个注册流程的类。

 public class RegisterUtils
    {
        //传统的解决方案,在一个方法里书写各种业务。
        //缺点：后期需求变更了,当需要插入更多数据的时候,只能修改该方法内部逻辑,不符合开闭原则


        //下面介绍利用多播委托进行解耦插件式开发
        public delegate void myRegisterDelegate(string userName, string userPwd);

        public static void myRegister(myRegisterDelegate mrd, string userName, string userPwd)
        {
            //对密码进行Md5加密后在进行后续操作
            string md5userPwd = userPwd + "MD5";  //模拟Md5
            mrd.Invoke(userName, md5userPwd);
        }
        /// <summary>
        /// 查询方法
        /// </summary>
        public static void checkIsRegister(string userName, string userPwd)
        {
            Console.WriteLine("查询成功");
        }
        /// <summary>
        /// 向表1中插入数据
        /// </summary>
        public static void writeTable1(string userName, string userPwd)
        {
            Console.WriteLine("向表1中插入数据{0}，{1}",userName,userPwd);
        }
        /// <summary>
        /// 向表2中插入数据
        /// </summary>
        public static void writeTable2(string userName, string userPwd)
        {
            Console.WriteLine("向表2中插入数据{0}，{1}", userName, userPwd);
        }
        /// <summary>
        /// 向表3中插入数据
        /// </summary>
        public static void writeTable3(string userName, string userPwd)
        {
            Console.WriteLine("向表3中插入数据{0}，{1}", userName, userPwd);
        }
    }

调用

   Console.WriteLine("--------------------------3.多播委托的案例（在注册流程中） ------------------------------------");
                RegisterUtils.myRegisterDelegate mrd = RegisterUtils.checkIsRegister;
                mrd += RegisterUtils.writeTable1;
                mrd += RegisterUtils.writeTable2;
                //需求增加了,向表3中添加数据
                mrd += RegisterUtils.writeTable3;
                //需求变更了,删除向表2中添加数据
                mrd -= RegisterUtils.writeTable2;
                RegisterUtils.myRegister(mrd, "maru", "123");

结果：

　　补充：在下一个章节：.Net进阶系列(7)-委托和事件(二)中，会继续介绍泛型委托、内置委托、委托的其他性质、委托和事件。