.NET编程（03）Lambda&Linq（to object）

.NET编程（03）Lambda&Linq（to object）

什么是Lambda式

public delegate void NoReturnWithPara(int id, string name)
NoReturnWithPara method=(id,name)=>
{
console.WriteLine("ssss");
}
method.Invoke(123,"123");//委托实例调用

lambda表达式即为一个匿名方法

系统自带无返回值委托:Action(0到16个参数的无返回值泛型委托)
Action <string> act=t=>console.write("ss")//一个参数时候可以省略小括号

系统自带有返回值委托:Func<参数类型，返回值类型>(0到16个参数的带返回值泛型委托)
Func<string> fun=()=>DateTime.Now.ToShortDateString();
Console.writeLine(fun.Invoke());//无参数带string类型返回值委托
Func<string,int> fun2=t=>DateTime.Now.ToShortDateString();
console.write(fun2.Invoke("sss"));有参数带int类型返回值委托

匿名类

var model=new
{
id=1，
name="123"，
age=23
}；//内部属性可以根据自己需要随便定义，定义之后属性值不能再改变，只能访问
Console.writeline(model.name);
var 只能声明局部变量，不能是字段和静态属性，声明的时候必须被初始化

扩展方法

扩展方法：静态类里面的静态方法，在第一个参数类型前加上this关键字

public static class ExtendShow
{
public static int ToInt（this int？ iparameter）
{
return iparameter ?? -1;
}
}
//int? iparameter:表示该参数可以为空
//iparameter ?? -1;三元表达式，表示如果为空返回-1，不为空则返回本身的值

//给LambdaShow类添加扩展方法
public static void ExtendShow(this LambdaShow lambdaShow ,String sParameter ,int iParameter)
{
Console.Writeline($"LambdaShow=={iParameter}=={sParameter}")
}

//当扩展方法和类的实例方法重名的时候，会优先实例方法，若扩展方法不改方法名将永远不会被执行
public static void Show(this LambdaShow lambdaShow )
{
Console.Writeline($"LambdaShow")
}

//LambdaShow类
public class LambdaShow
{
public void Show(){}
}

扩展方法的调用

int？ ivalue =null;
ExtendShow.ToInt(ivalue);
ivaule.ToInt();

new LambdaShow().ExtendShow("123",123);
new LambdaShow().Show();//会优先调用实例方法

优点：在不修改原有类型的封装基础上，给类添加额外的功能

注意点：在使用扩展方法的时候，不要滥用，不要给基类添加扩展方法（如：object）

Linq to object

public class Student
{
public int Id { get; set; }
public int ClassId { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public void Study() { }
}
public class Class
{
public int Id { get; set; }
public string ClassName { get; set; }
}

List<Student> stuList=new List<Student>();
List<Class> classList = new List<Class>()

**查询运算符写法**
var list=stuList.Where<Student>(s=>
{
Consolo.WriteLine("sss");//迭代器的延迟（代码第一次到此处不会被打印，只有在遍历list集合的时候才会被打印）
s.age>30;
});
//linq to object 延迟，按需获取，只有在真实遍历的时候，才会执行上面lambda表达式计算，原理是属于迭代器的迟延
var list=stuList.Where<Student>(s=>{s.age>30;}).Tolist();//非延迟

**查询表达式的写法**
var list=from s in stuList where s.age<30 && s.name.length>3 select s;
//查询表达式的写法在编译后会编译成查询运算符的写法，两种写法是等同的

投影（为每个筛选后的对象创建一个新的匿名类/实体类）
第一种写法
var list =stuList.Where<student>(s=>s.age<30).select(s=>new
{
Id=s.id;
IdName=s.id+s.name,
ClassName=s.classid==2?"A班":"B班"
})
.OrderBy(s=>s.Id)//按Id升序排列
.OrderByDescending(s => s.Id)//按Id降序序排列
.ThenBy(s=>s.IdName)//对排序后的数据再通过s.IdName进行排序
.Skip(2)//跳过两条数据，用来分页处理
.Take(3)//获取前3条数据
;

foreach（var item  in list）//新建对象不在具备有以前的属性，只具有匿名类中的属性
{console.writeline(item.Idname,item.ClassName)}
第二种写法
var list =from s in stulist where s.age<30 select new
{
IdName=s.id+s.name,
ClassName=s.classid==2?"A班":"B班"
};

内连(inner join)
第一种写法
var list=from s in stulist Join c in classlist on s.classid equals c.id select  new {name =s.name};
第二种写法
var list =stulist.Join(classList,s=>s.classid,c=>c.id,(s,c)=>new{name=s.name});

左连（left join）：没有右连接，右连接改变两个集合的位置即可
var list=from s in stulist join c in classlist on s.classid equals c.classid into SCList
from sc in SCList.DefaultIfEmpty()
select new {name=s.name};

var list=stulist.Join(classlist,s=>s.classId,c=>c.classId,(s,c)=>new
{
name=s.name,
classname=c.classname
}).DefaultIfEmpty();