lambda，linq

一：什么是Lambda表达式

lambda表达式是实例化委托的一个参数，就是一个方法，具体实现如下：

 1 {
 2     //.NetFramework 1.0-1.1的时候这样应用
 3     NoReturnNoPara method = new NoReturnNoPara(DoNothing);
 4     method.Invoke();
 5 
 6 
 7     //.NetFramwork2.0 匿名方法出现，delegate关键字，可以访问局部变量
 8     int i = 0;
 9     NoReturnWithPara method1 = new NoReturnWithPara(delegate (int id, int age)
10     {
11         Console.WriteLine(i);
12         Console.WriteLine($"{id} 今年{age}岁了!");
13     });
14     method1.Invoke(1, 30);
15 
16 
17     //.NetFramwork3.0 把delegate关键字去掉，然后增加了一个箭头goes to
18     //lambda表达式：参数列表=>方法体
19     NoReturnWithPara method2 = new NoReturnWithPara((int id, int age) =>
20     {
21         Console.WriteLine(i);
22         Console.WriteLine($"{id} 今年{age}岁了!");
23     });
24     method2.Invoke(1, 30);
25 
26     NoReturnWithPara method3 = new NoReturnWithPara((id, age) =>
27     { //省略参数类型，但是编译器可以根据委托推断出类型，是语法糖
28         Console.WriteLine(i);
29         Console.WriteLine($"{id} 今年{age}岁了!");
30     });
31     method3.Invoke(1, 30);
32 
33     //如果方法体只有一行，可以去掉大括号和分号
34     NoReturnWithPara method4 = new NoReturnWithPara((id, age) => Console.WriteLine($"{id} 今年{age}岁了!"));
35     method4.Invoke(1, 30);
36 
37     //如果方法体只有一行，可以去掉大括号和分号,还可以去掉new NoReturnWithPara，这个也是编译器语法糖
38     NoReturnWithPara method5 = (id, age) => Console.WriteLine($"{id} 今年{age}岁了!");
39     method4.Invoke(1, 30);
40 
41     //下面带有返回值的
42     Func<int> func0 = () => { return DateTime.Now.Month; };//有一个返回值
43     Func<int> func1 = () => DateTime.Now.Month; //如果方法体只有一行，去掉大括号分号和return
44 
45 }

View Code

使用反编译工具看会产生一个私有sealed类，然后会看到lambda表达式都会生成一个方法名字，然后都会在包括在Sealed类里面

二：匿名类(.netFramwork3.0)

匿名类是.netFramwork3.0出现的，语法是：object object=new{};

下面有几种声明方式：

 1    object model = new//3.0
 2    {
 3        Id = 2,
 4        Name = "undefined",
 5        Age = 25,
 6        ClassId = 2
 7    };
 8   // Console.WriteLine(model.Id);//object 编译器不允许
 9 
10    var varModel = new//3.0  编译后是有一个真实的类
11    {
12        Id = 2,
13        Name = "undefined",
14        Age = 25,
15        ClassId = 2
16    };
17    Console.WriteLine(varModel.Id); //编译器可以找到
18    //varModel.Id = 123;//只能get 没有set
19    //反射可以找到
20 
21 
22    //dynamic避开编译器
23    dynamic dModel = new//4.0
24    {
25        Id = 2,
26        Name = "undefined",
27        Age = 25,
28        ClassId = 2
29    };
30 
31    var s = dModel;

下面说一下var这个类型

var：是一个语法糖，由编译器自动推算出变量的类型，一般配合匿名类型使用，然后如遇到复杂类型，可以用之代替，但使用时，以下几点需要注意：

1：var声明的时候一定要确定类型，比如var dd=null或者var aa; 都是编译不通过的

2：一旦确定类型后是不能修改类型的，比如： var s = "加菲猫";则后面不能修改为：s=122;

三：扩展方法(.netFramwork3.0)

什么是扩展方法？答案则是静态类里面的静态方法，第一个参数类型前面加上this

具体如下：

 1 public static class ExtendMethod
 2 {
 3     public static void Show<T>(this T t)//最好加约束
 4     { }
 5 
 6     public static void Sing(this Student student)
 7     {
 8         Console.WriteLine($"{student.Name} Sing a Song");
 9     }
10 
11     /// <summary>
12     /// null默认是defaultValue,默认是0
13     /// </summary>
14     /// <param name="iValue"></param>
15     /// <param name="defaultValue"></param>
16     /// <returns></returns>
17     public static int ToInt(this int? iValue, int defaultValue = 0)
18     {
19         return iValue ?? defaultValue;
20     }
21 
22     public static bool Than(this int value1, int value2)
23     {
24         return value1 > value2;
25     }
26 
27 
28     /// <summary>
29     /// 扩展基类型，导致任何子类都有这个方法，而且还可能被覆盖啥的
30     /// </summary>
31     /// <param name="iValue"></param>
32     /// <returns></returns>
33     public static int Length(this object oValue)
34     {
35         return oValue == null ? 0 : oValue.ToString().Length;
36     }
37 
38 }

View Code

然后调用的时候如下：

int? iValue1 = nul
int? iValue = 2;
iValue1.ToInt();
iValue1.Length(); 
s.Length();
123.Than(234);

扩展方法的用途：

1：适合用于一些不经常修改的地方
2：适合组件式开发的扩展(.netcore)，定义接口或者类，是按照最小需求，但是开发的时候又经常需要一些方法，就是通过扩展方法，context.Response.WriteAsync
还有中间件的注册
3：扩展一些常见操作

扩展方法缺陷：优先调用类型的实例方法(有隐患)，会污染基础类型，一般少为object 或者没有约束的泛型去扩展，扩展基类型，导致任何子类都有这个方法，而且还可能被覆盖啥的

三：linq

linq和lamda的关系：

lambda和linq的关系
lambda：是实例化委托的快捷方式，是一个方法
linq：是基于委托（lambda）的封装，代码重用，逻辑解耦，是一个帮助类库
linq是用泛型，委托，lamda实现的

猜你喜欢