示例#1
0
        public static void Show()
        {
            Student student = new Student();//声明类以及调用

            student.Id   = 11;
            student.Name = "";
            student.Study();
            NoReturnWithPara method  = new NoReturnWithPara(Plus); //2委托的实例化,传入一个方法名称 要求方法签名一致
            NoReturnWithPara method1 = Plus;                       //简明声明委托

            //用Lamdba表达式实现
            {
                NoReturnWithPara method2 = (x, y) => Console.WriteLine("x={0},y={1}", x, y); //匿名方法体
            }
            method.Invoke(1, 2);                                                             //3调用
            method.BeginInvoke(1, 2, null, null);                                            //没有委托就没有异步
            method(1, 2);                                                                    //调用
            Plus(4, 5);
            method += Plus;
            method += Plus;
            method += Plus;
            method -= Plus;//多播委托

            //foreach (NoReturnNoPara item in method.GetInvocationList())//获取委托的实列
            //{
            //    item.Invoke();
            //}
        }
示例#2
0
        public void Show()
        {
            int k = 1;
            {
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
            }

            {
                //anonymous methods
                NoReturnNoPara method = new NoReturnNoPara(delegate()
                {
                    Console.WriteLine("this is do nothing in anonymous methods");
                });
            }

            {
                //Lambda expression
                NoReturnNoPara method = new NoReturnNoPara(() =>    //"=>" is called goes to.
                {
                    Console.WriteLine("this is do nothing in anonymous methods");
                });
            }
            {
                // Lambda expression is not a delegation, or an instance of a delegation. It's a class in another class, a internal method.
                NoReturnWithPara method  = new NoReturnWithPara((int x, int y) => { });
                NoReturnWithPara method1 = new NoReturnWithPara((x, y) => { }); // int could be ignored
                NoReturnWithPara method2 = (int x, int y) => { };               //left is decleration, right is a lambda expression
            }
        }
示例#3
0
        public void DetegateChangeCode()
        {
            //1. 1.0 1.1版本时的写法
            NoReturnWithPara method1 = new NoReturnWithPara(this.WithParaNothing);

            //2.0时的写法
            NoReturnWithPara method2 = new NoReturnWithPara(delegate(int x, string s)
            {
                Console.WriteLine("带参数的方法{0} - {1}", x, s);
            });

            //3.0时的写法
            NoReturnWithPara method3 = new NoReturnWithPara((int x, string s) =>
            {
                Console.WriteLine("带参数的方法{0} - {1}", x, s);
            });

            NoReturnWithPara method4 = new NoReturnWithPara((x, s) =>
            {
                Console.WriteLine("带参数的方法{0} - {1}", x, s);
            });

            NoReturnWithPara method5 = new NoReturnWithPara((x, s) => Console.WriteLine("带参数的方法{0} - {1}", x, s));
            NoReturnWithPara method6 = ((x, s) => {
                Console.WriteLine("带参数的方法{0} - {1}", x, s);
                Console.WriteLine("111");
            });
        }
示例#4
0
        public void Show()
        {
            int k = 1;
            {
                //.NET 1.0, 1.1
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
            }
            {
                // 2.0 匿名方法 访问到调用地方的变量

                NoReturnNoPara method = new NoReturnNoPara(delegate()
                {
                    Console.WriteLine("DO Nothing");
                    Console.WriteLine(k);
                });
            }
            {
                // 3.0 lambda 左边是参数列表  goes to   右边是方法体  本质就是一个方法

                NoReturnNoPara method = new NoReturnNoPara(() => // goes to
                {
                    Console.WriteLine("DO Nothing");
                    Console.WriteLine(k);
                });
            }

            {
                NoReturnWithPara method = new NoReturnWithPara((int x, int y) =>
                {
                    Console.WriteLine("DO Nothing");
                    Console.WriteLine(k);
                });
            }
            {
                // 可以省略参数类型 自动推算 要么都声明参数类型,要么都不声明
                NoReturnWithPara method = new NoReturnWithPara((x, y) =>
                {
                    Console.WriteLine("DO Nothing");
                    Console.WriteLine(k);
                });
            }
            {
                // 方法体只有一行可以省略大括号
                NoReturnWithPara method = (x, y) =>
                {
                    Console.WriteLine("DO Nothing");
                };

                // lambda 表达式是什么?
                // 首先不是委托 委托是类型
                // 也不是委托的实例
                // 只是一个方法 (作用)
                // 实际上编译后是一个类中类,里面的一个internal 方法, 然后被绑定到静态委托类型字段
            }
        }
示例#5
0
        public void Show()
        {
            int k = 1;
            {
                //1.0  1.1
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
            }
            {
                //2.0 匿名方法
                NoReturnNoPara method = new NoReturnNoPara(delegate()
                {
                    Console.WriteLine(k);//能直接用到这里的变量
                    Console.WriteLine("This is DoNothing1");
                });
            }
            {
                //3.0 lambda:左边是参数列表 goes to  右边是方法体   本质就是一个方法
                NoReturnNoPara method = new NoReturnNoPara(() =>//goes to
                {
                    Console.WriteLine("This is DoNothing2");
                });
            }
            {
                NoReturnWithPara method = new NoReturnWithPara((int x, int y) => { Console.WriteLine("This is DoNothing3"); });
            }
            {//可以省略掉参数类型  自动推算的
                NoReturnWithPara method = new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
            }
            {//方法体只有一行,可以去掉大括号和分号
                NoReturnWithPara method = new NoReturnWithPara((x, y) => Console.WriteLine("This is DoNothing5"));
            }


            {
                //可以省略  编译器推算的
                NoReturnWithPara method = (x, y) => Console.WriteLine("This is DoNothing6");
            }//lambda表达式是个什么呢?
             //首先不是委托  委托是类型
             //然后也不是委托的实例  因为这里是省略new 委托()
             //只是一个方法(作用)
             //实际上是一个类中类,里面的一个internal方法,然后被绑定到静态的委托类型字段

            {
                NoReturnWithPara method = new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
                method += new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
                method -= new NoReturnWithPara((x, y) => { Console.WriteLine("This is DoNothing4"); });
                method.Invoke(123, 234);//还是执行2遍  lambda的注册是去不掉的
            }


            {
                Action <int> act = i => { };
            }
        }
示例#6
0
        public void Show()
        {
            //2.实例化委托
            NoReturnNoPara delegateNoParaObj = new NoReturnNoPara(this.DoNothing);

            delegateNoParaObj.Invoke();

            NoReturnWithPara delegateWithParaObj = new NoReturnWithPara(this.WithParaNothing);

            delegateWithParaObj.Invoke(2, "sss");



            for (int i = 0; i < 10; i++)
            {
                delegateWithParaObj.BeginInvoke(i, i.ToString(), delegate(IAsyncResult t)
                {
                    Console.WriteLine("当前线程ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                }, "哈哈哈");
            }
        }
示例#7
0
        //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;
                //等价于 bool methord(int x) => x > 6;
                Console.WriteLine(methord(8));
            }
        }
示例#8
0
        public void Show()
        {
            string nameOut = "糯米飞机";
            {
                Student student = new Student();
                student.Id      = 1;
                student.Name    = "打兔子的猎人";
                student.Age     = 27;
                student.ClassId = 2;

                student.Study();
            }
            {
                Student student = new Student()
                {
                    Id      = 1,
                    Name    = "打兔子的猎人",
                    Age     = 27,
                    ClassId = 2
                };
                student.Study();
            }
            {
                NoReturnWithPara method = new NoReturnWithPara(this.DoNothing); //2 委托的实例化
                method.Invoke(1, "Gain");                                       //3 委托的调用
            }
            {
                NoReturnWithPara method = this.DoNothing;
                method.Invoke(2, "憨豆");
            }

            {
                NoReturnWithPara method = new NoReturnWithPara(
                    delegate(int id, string name)
                {
                    Console.WriteLine(nameOut);
                    Console.WriteLine("{0} {1} DoNothing");
                });
                method.Invoke(3, "yoyo");
            }
            {
                NoReturnWithPara method = new NoReturnWithPara(
                    (int id, string name) =>              //goes to
                    //lambda表达式:是一个匿名方法,是一个方法
                {
                    Console.WriteLine(nameOut);
                    Console.WriteLine("{0} {1} DoNothing");
                });
                method.Invoke(4, "Nine");
            }
            {
                NoReturnWithPara method = new NoReturnWithPara(
                    (id, name) =>
                    //去掉参数类型,原因是委托的约束
                {
                    Console.WriteLine("{0} {1} DoNothing");
                });
                method.Invoke(5, "小昶");
            }
            {
                //如果方法体只有一行,那么可以去掉大括号和分号,多行不行
                //如果参数只有一个  可以去掉小括号
                //如果没有参数,直接用小括号

                NoReturnWithPara method = new NoReturnWithPara((id, name) => Console.WriteLine("{0} {1} DoNothing", id, name));
                method.Invoke(6, "梦醒时分");
            }
            {
                NoReturnWithPara method = (id, name) => Console.WriteLine("{0} {1} DoNothing", id, name);
                method.Invoke(7, "小石头");
                method(8, "Y");
            }

            {
                //0到16个参数  无返回值的委托
                Action       act1 = () => Console.WriteLine("1234");
                Action <int> act2 = t => { };
                Action <int, NoReturnWithPara, LambdaShow, LambdaShow, string, string, string, string, string, string, string, string, string, string, string, string> act3 = null;
                Action <int, NoReturnWithPara, NoReturnWithPara, LambdaShow, LambdaShow, string, string, string, string, string, string, string, string, string, string, string, string> act4 = null;
            }
            {
                //0到16个参数  带返回值的委托
                Func <int> func1 = () => 1;
                int        i     = func1();

                Func <int, string> func2 = t => "1234";
                Func <int, int, NoReturnWithPara, LambdaShow, LambdaShow, string, string, string, string, string, string, string, string, string, string, string, string> func3 = null;
            }
            {
                //多返回值:1 返回对象  2  ref out
                WithReturnWithParaRefOut method = new WithReturnWithParaRefOut(
                    delegate(ref DateTime time, out int i)
                {
                    i = 1;
                    return(this);
                });    //lambda表达式不行
            }
        }
示例#9
0
        public static void Show()
        {
            NoReturnWithPara method = new NoReturnWithPara(Study);//委托实例化,要求传入的方法必须满足委托的约束

            method.Invoke("jack", DateTime.Now);

            NoReturnWithPara method1 = new NoReturnWithPara(
                delegate(string name, DateTime now) {
                Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
            });    //使用匿名方法,把方法名去掉

            method1.Invoke("jack", DateTime.Now);

            NoReturnWithPara method2 = new NoReturnWithPara(
                (string name, DateTime now) =>
            {
                Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
            });   //Lmabda表达式   把delegate换成了=>

            method2.Invoke("jack", DateTime.Now);

            NoReturnWithPara method3 = new NoReturnWithPara(
                (name, now) =>
            {
                Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
            });   //去掉了参数类型,委托实例化要求传入的方法必须满足委托的约束

            method3.Invoke("jack", DateTime.Now);


            NoReturnWithPara method4 = (name, now) =>
            {
                Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);
            };   //去掉了new NoReturnWithPara();

            method4.Invoke("jack", DateTime.Now);

            NoReturnWithPara method5 = (name, now) => Console.WriteLine("{0}{1}正在学习Lambda表达式", name, now);

            //去掉了{},条件是方法体只有一行;
            method5.Invoke("jack", DateTime.Now);


            NoReturnWithPara method10 = (s, b) => Console.WriteLine("{0}{1}正在学习Lambda表达式", s, b);

            method10.Invoke("jack", DateTime.Now);

            Console.WriteLine("===============================================");

            WithReturnWithoPara func  = (x, y) => { return(x * y); };
            WithReturnWithoPara func1 = (x, y) => x * y;//去掉了{},条件是方法体只有一行,带返回值的话,return就去掉;

            func.Invoke(3, 4);
            func1.Invoke(3, 4);

            Console.WriteLine("===============================================");

            NoReturnNoPara action  = () => { };
            NoReturnNoPara action1 = () => { Console.WriteLine("12345"); };

            Console.WriteLine("===============================================");
            WithReturnNoPara fun = () => "erfdfa";

            Console.WriteLine("===============================================");
            //系统自带的各种委托
            #region  带返回值的委托
            Action act1 = () => { };
            //泛型委托
            Action <string> act2 = name => { Console.WriteLine(); };//一个参数的话,可以去掉小括号
            //最多可以有16个参数
            Action <string, int, long, DateTime, char, double, decimal> act3 = (par1, par2, par3, par4, par5, par6, par7) => { };
            #endregion

            #region 带返回值的委托
            Func <string>   fun1 = () => "fdafds";
            Func <DateTime> fun2 = () => DateTime.Now;
            //最多可以有16个参数,带一个返回值
            Func <string, int, long, DateTime, char, double, decimal, DateTime> fun3 = (par1, par2, par3, par4, par5, par6, par7) => DateTime.Now;
            Func <string, int, long, DateTime, char, double, decimal, Action>   fun4 = (par1, par2, par3, par4, par5, par6, par7) => act1;



            #endregion
        }
示例#10
0
        public void Show()
        {
            {
                NoReturnWithPara func = (x, y) => { };
                func += (x, y) => Console.WriteLine("123");;

                func.Invoke(3, 4);
            }



            //System.MulticastDelegate
            Student student = new Student()
            {
                Id   = 96,
                Name = "Summer"
            };

            student.Study();

            //Predicate<int>

            //Func<string>

            {
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);//2 委托的实例化


                method.Invoke();//3 委托的调用
                method();

                //method.BeginInvoke(null, null);

                this.DoNothing();
            }

            {
                NoReturnNoPara method  = new NoReturnNoPara(this.DoNothing);             //当前类的实例方法
                NoReturnNoPara method1 = new NoReturnNoPara(MyDelegate.DoNothingStatic); //当前类的静态方法
                NoReturnNoPara method2 = new NoReturnNoPara(student.Study);              //其他类的实例方法
                NoReturnNoPara method3 = new NoReturnNoPara(Student.StudyAdvanced);      //其他类的静态方法
            }

            {
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
                method += new NoReturnNoPara(this.DoNothing);
                method += new NoReturnNoPara(MyDelegate.DoNothingStatic);
                method += new NoReturnNoPara(student.Study);
                method += new NoReturnNoPara(Student.StudyAdvanced);

                method += new NoReturnNoPara(new Student().Study);
                method += new NoReturnNoPara(Student.StudyAdvanced);


                method += new NoReturnNoPara(() => Console.WriteLine("这里是lambda表达式"));
                //+=就是把多个方法按顺序排成列表,invoke时按顺序执行
                //method.Invoke();

                method -= new NoReturnNoPara(this.DoNothing);
                method -= new NoReturnNoPara(MyDelegate.DoNothingStatic);
                method -= new NoReturnNoPara(student.Study);

                method -= new NoReturnNoPara(new Student().Study);
                method -= new NoReturnNoPara(Student.StudyAdvanced);

                method -= new NoReturnNoPara(Student.StudyAdvanced);
                method -= new NoReturnNoPara(() => Console.WriteLine("这里是lambda表达式"));
                //-=就是从这个实例上,从后往前挨个匹配,找到第一个完全吻合的移除掉,且只移除一个,找不到不异常
                method.Invoke();


                //method.BeginInvoke(null, null);
                foreach (NoReturnNoPara item in method.GetInvocationList())
                {
                    item.BeginInvoke(null, null);
                }
            }
        }
示例#11
0
        public void Show()
        {
            {
                //1.0最普通的写法
                NoReturnWithPara mathod = new NoReturnWithPara(this.TestFunction); //实例化委托
                mathod.Invoke(123, "hzq");                                         //委托实例的调用
            }

            {
                //2.0方法,匿名方法
                NoReturnWithPara mathod = new NoReturnWithPara(
                    delegate(int id, string name)
                {
                    Console.WriteLine($"ID:{id},Name:{name}");
                }
                    );
                mathod.Invoke(123, "hzq");
            }

            {
                //3.0 Lambda表达式
                NoReturnWithPara mathod = new NoReturnWithPara(
                    (int id, string name) => //gose to Lambda表达式,左边是参数列表右边是方法体
                {
                    Console.WriteLine($"ID:{id},Name:{name}");
                }
                    );
                mathod.Invoke(123, "hzq");
            }

            {
                //Lambda表达式的语法糖,省略类型
                NoReturnWithPara mathod = new NoReturnWithPara(
                    (id, name) =>
                {     //编译器语法糖
                    Console.WriteLine($"ID:{id},Name:{name}");
                }
                    );
                mathod.Invoke(333, "cc");
            }
            {
                //Lambda表达式的进一步缩减
                NoReturnWithPara mathod = (id, name) => Console.WriteLine($"ID:{id},Nmae:{name}");
                mathod.Invoke(30789, "hzq");
            }

            //.Net3.0系统自带的委托,Action,Func
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Lambda表达式(系统自带委托,无参数无返回值)");
            {
                //1.0
                Action act = new Action(this.TestNoParaFuntion);
                act.Invoke();
            }
            {
                //2.0
                Action act = new Action(
                    delegate()
                {
                    this.TestNoParaFuntion();
                }
                    );
                act.Invoke();
            }
            {
                Action act = new Action(
                    () => this.TestNoParaFuntion()
                    );
                act.Invoke();
            }
            {
                Action act = () => this.TestNoParaFuntion();
                act.Invoke();
            }

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Lambda表达式(系统自带委托,有参数无返回值)");
            {
                //2.0匿名函数
                Action <int, string> act = new Action <int, string>( //泛型委托
                    delegate(int id, string name) {
                    Console.WriteLine($"ID:{id},Name:{name}");
                }
                    );
                act.Invoke(6666, "HZQ");
            }
            {
                //3.0写法,lambda表达式
                Action <int, string> act = (id, name) => Console.WriteLine($"ID:{id},Nmae:{name}");
                act.Invoke(567, "HZQ");
            }
        }
示例#12
0
        public void Show()
        {
            Console.WriteLine("lambda演变历史");

            {
                Console.WriteLine(".NetFramework1.0  1.1");
                Console.WriteLine("执行无参无返回值委托");
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
                method.Invoke();
            }
            {
                Console.WriteLine("执行有参无返回值委托");
                NoReturnWithPara method = new NoReturnWithPara(this.Study);
                method.Invoke(20200316, "2020年3月16日17:56:21");
            }
            {
                Console.WriteLine(".NetFramework2.0  匿名方法,delegate关键字");
                //可以访问局部变量
                NoReturnWithPara method = new NoReturnWithPara(delegate(int id, string name)
                {
                    Console.WriteLine($"***这是方法***:匿名方法:{id} {name}");
                });
                method.Invoke(20200316, "2020年3月16日17:02:23");
            }
            {
                Console.WriteLine(".NetFramework3.0   把delegate关键字去掉,增加了一个箭头goes to 也就是:=>");
                NoReturnWithPara method = new NoReturnWithPara(
                    (int id, string name) =>
                {
                    Console.WriteLine($"***这是方法***:{id} {name}");
                });
                method.Invoke(20200316, "2020年3月16日17:06:31");
                Console.WriteLine("Action方法");
                Action <string, string> actionA = (string str1, string str2) =>
                {
                    Console.WriteLine($"***这是方法***:参数1:{str1},参数2:{str2}");
                };
                actionA.Invoke("ABC", "CBA");
            }
            {
                Console.WriteLine("//省略参数类型,编译器的语法糖,虽然没写,编译时还是有的,根据委托推算");
                NoReturnWithPara method = new NoReturnWithPara(
                    (id, name) =>
                {
                    Console.WriteLine($"{id} {name}");
                });
                method.Invoke(20200316, "2020年3月16日17:13:11");

                Console.WriteLine("Action方法");
                Action <int, string> actionB = (int1, str1) =>
                {
                    Console.WriteLine($"***这是方法***:参数1{str1},参数2:{str1}");
                };
                actionB.Invoke(20200316, "2020年3月16日17:20:03");
            }
            {
                Console.WriteLine("如果方法体只有一行,可以去掉大括号和分号");
                NoReturnWithPara method = new NoReturnWithPara(
                    (id, name) => Console.WriteLine($"{id} {name}"));
                method.Invoke(20200316, "2020年3月16日17:22:59");
            }
            {
                Console.WriteLine("new NoReturnWithPara可以省掉,也是语法糖,编译器自动加上");
                NoReturnWithPara method = (id, name) => Console.WriteLine($"{id} {name}");
                method.Invoke(123, "大涛");
            }
            Console.WriteLine("lambda表达是什么? lambda只是实力化委托的一个参数,就是个方法");
            Console.WriteLine("lambda是匿名方法,但是编译的时候会分配一个名字,还会产生一个私有sealed类,这里增加一个方法");
            {
                Console.WriteLine("lambda在多播委托");
                NoReturnWithPara method = new NoReturnWithPara(this.Study);
                method += this.Study;
                method += (id, name) => Console.WriteLine($"{id} {name}");

                method -= this.Study;
                method -= (id, name) => Console.WriteLine($"{id} {name}");
                Console.WriteLine("多播委托里面的lambda无法移除, 不是2个实例,其实是2个不同的方法,因为在编译的时候,会生成两个方法名不同的方法");
                method.Invoke(20200316, "2020年3月16日17:26:12");
            }
            {
                Console.WriteLine("==========有返回值,有参数==========");
                Func <int, int, int> funcA = (a, b) =>
                {
                    return(a + b);
                };
                Console.WriteLine("如果方法体只有一行也可以省略大括号");
                Func <int, int, int> funcB = (a, b) => a + b;

                int c = funcA.Invoke(12, 13);
                int d = funcB.Invoke(10, 30);
                Console.WriteLine($"FuncA返回值:{c}");
                Console.WriteLine($"FuncB返回值:{d}");
            }
        }
示例#13
0
        public void Show()
        {
            //lambda演变历史

            {
                //.NetFramework1.0  1.1
                NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
            }
            int i = 10;
            {
                NoReturnWithPara method = new NoReturnWithPara(this.Study);
                method.Invoke(123, "董小姐");
            }
            {
                //.NetFramework2.0  匿名方法,delegate关键字
                //可以访问局部变量
                NoReturnWithPara method = new NoReturnWithPara(delegate(int id, string name)
                {
                    Console.WriteLine(i);
                    Console.WriteLine($"{id} {name} 学习.Net高级班");
                });
                method.Invoke(234, "Harley");
            }
            {
                //.NetFramework3.0   把delegate关键字去掉,增加了一个箭头goes to
                //lambda表达式  参数列表=>方法体
                NoReturnWithPara method = new NoReturnWithPara(
                    (int id, string name) =>
                {
                    Console.WriteLine($"{id} {name} 学习.Net高级班");
                });
                method.Invoke(123, "Coder");
            }
            {
                NoReturnWithPara method = new NoReturnWithPara(
                    (id, name) =>//省略参数类型,编译器的语法糖,虽然没写,编译时还是有的,根据委托推算
                {
                    Console.WriteLine($"{id} {name} 学习.Net高级班");
                });
                method.Invoke(123, "加菲猫");
            }
            {
                NoReturnWithPara method = new NoReturnWithPara(
                    (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班"));
                //如果方法体只有一行,可以去掉大括号和分号
                method.Invoke(123, "ZJ");
            }
            {
                NoReturnWithPara method = (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班");
                method.Invoke(123, "大涛"); //new NoReturnWithPara可以省掉,也是语法糖,编译器自动加上
            }
            //lambda表达是什么? lambda只是实力化委托的一个参数,就是个方法
            //lambda是匿名方法,但是编译的时候会分配一个名字
            //还会产生一个私有sealed类,这里增加一个方法
            {
                //lambda在多播委托
                NoReturnWithPara method = new NoReturnWithPara(this.Study);
                method += this.Study;
                method += (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班1");

                method -= this.Study;
                method -= (id, name) => Console.WriteLine($"{id} {name} 学习.Net高级班1");
                //多播委托里面的lambda无法移除, 不是2个实例,其实是2个不同的方法
                method.Invoke(345, "北纬23");
            }
            {
                //匿名方法或者lamdba表达式是不是只能是无返回值的
                Action          action0 = () => { };
                Action <string> action1 = s => Console.WriteLine(s); //参数只有一个  可以省略小括号
                Func <int>      func0   = () => DateTime.Now.Month;  //如果方法体只有一行,去掉大括号分号return
                int             iResult = func0.Invoke();
            }
        }