Lambda演变

.lambda表达式究竟是什么？---就是一个匿名函数---在底层会生成在一个"<>"类中，生成带有名称的方法；  

lambda   语法糖： 借了委托的壳而已，执行的是方法，本质是一个函数。并不是委托

Lambda 演化

public delegate void NoReturnNoPara();
public delegate void NoReturnWithPara(int x, string y);//1 声明委托
public delegate int WithReturnNoPara();
public delegate string WithReturnWithPara(out int x, ref int y);

 

      
      {
                //.Netframework1.0/1.1时代
                int j = 0;
                NoReturnNoPara method = new NoReturnNoPara(DoNothing);
                NoReturnWithPara method1 = new NoReturnWithPara(Study);
                method1.Invoke(123, "Richard");
            }
            ///.NetFramework2.0  匿名方法  增加了一个delegate关键字,可以访问到除了参数以外的局部变量
            int i = 0;
            {
                NoReturnWithPara method = new NoReturnWithPara(delegate (int x, string y)
                {
                    Console.WriteLine(x);
                    Console.WriteLine(y);
                    Console.WriteLine(i);
                });
            }
            .NetFramework3.0  去掉delegate关键了，在参数的后增加了一个 => goes to
            {
                NoReturnWithPara method = new NoReturnWithPara((int x, string y) =>
                {
                    Console.WriteLine(x);
                    Console.WriteLine(y);
                    Console.WriteLine(i);
                });
            }
            {
                //.NetFramework3.0 后期，去掉了匿名方法红的参数类型--为什么可以去掉？  语法糖：编译器提供的便捷功能；可以推导出类型的参数
                NoReturnWithPara method = new NoReturnWithPara((x, y) =>
                {
                    Console.WriteLine(x);
                    Console.WriteLine(y);
                    Console.WriteLine(i);
                });

            }
            {
                //如果匿名方法体中只有一行代码，可以省略方法体的大括号； 
                NoReturnWithPara method = new NoReturnWithPara((x, y) => Console.WriteLine(x));
                NoReturnWithPara method1 = (x, y) => Console.WriteLine(x);
                NoReturnWithPara method2 = (x, y) => global::System.Console.WriteLine(x);
            }
            {
                一个参数的时候；如果只有一个参数-- - 参数的小括号也可以省略掉
                Action<string> method = s => Console.WriteLine("欢迎大家来到.Net高级班进阶学习");
                method.Invoke("牧羊人。。");


            }

////如果有返回值？ 如果lambda表达式中只有一行代码，且有返回值，可以省略return;

                Func<string> func1 = new Func<string>(() =>
                {
                    return "";
                });

                Func<string> func2 = () =>
                {
                    return "";
                };
                Func<string> func3 = () => "";

匿名类演变

  Student student = new Student()
                    {
                        Id = 1,
                        Name = "Nochat",
                        Age = 25,
                        ClassId = 2
                    };
                    student.Study();
 object model = new//3.0    
                    {
                        Id = 1,
                        Name = "Nochat",
                        Age = 25,
                        ClassId = 2
                    }; 

                    //无法访问属性值
                    // Console.WriteLine(model.Id); //为什么？因为C#是强类型语言，object是在编译时确定类型； 因为Object没有这个属性； 
                    //Console.WriteLine(model.Name);
//dynamic避开编译器检查 (4.0)  .NETFramework
                    //(动态类型)，可以避开编译器的检查
                    dynamic dModel = new//  dynamic可以便可编译器的检查,运行时检查
                    {
                        Id = 1,
                        Name = "Nochat",
                        Age = 25,
                        ClassId = 2
                    };
                 
                    dModel.Id = 134;

                   // dModel.abccc = 1234; //也不报错了---实例中其实是没有这个属性的；
//var 语法糖   可以理解为弱类型；不确定类型；
                    Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                    var model1 = new //1.不能声明方法 2.不能给属性重新赋值  只能在初始化的时候，给定一个值；
                    {
                        Id = 1,
                        Name = "Nochat",
                        Age = 25,
                        ClassId = 2
                    };
 Console.WriteLine(model1.Id); //var 定义的匿名类，可以访问存在的属性值；
                    Console.WriteLine(model1.Name);
                      //Console.WriteLine(model1.Js); 
                     // model1.Id = 3; // 属性是只读，不能设置值；


                    Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                    int i2 = 2;
                    var i1 = 1;//var就是个语法糖，由编译器自动推算  
                    var s = "Richard";

                     
                    //var strnull = null; //编译器不允许； 
                    // var aa;//var声明的变量必须初始化，必须能推算出类型
                    //也不允许作为方法的参数类型 
                    ////1 var 配合匿名类型使用
                    ////2 var 偷懒，复杂类型的使用 
                    ////3 在不知道具体是什么类型的时候就可以使用var 来声明； 
                    //缺陷：个人认为，在代码阅读的时候不是很方便；
                    //建议大家在写代码的时候，尽量明确类型；