1.委托是一个类，可以声明，实例化，调用方法；
2.事件是一个委托的实例+event关键字修饰，有安全限制
3.lambda是一个匿名方法，是一个语法糖；编译器会生成一个委托调用的方法；
4.ling where ，select,是基于委托的代码封装，把数据筛选的通用逻辑完成，把判断交给委托传递；基于委托封装，完成代码复用

 

 

委托delegate-event：ILSPY(C#--IL--二进制）
1.委托是一个类，可以声明，实例化，调用方法；
可以把方法包裹成变量，逻辑解耦，保存稳定
代码复用，保证项目规范

1.声明：public delegate void mydelegate();
2.实例化：mydelegate mdl=new mydelegate(this.nothing);
3.调用方法：mdl.Invoke();mdl.beginInvoke()'
4.多播委托：就像一个容器，可以放入指定标准的多个方法，可以指定移除，invoke按顺序调用，一一执行。
5.委托和事件的区别：委托是一个类，事件是一个委托的实例+event关键字修饰，有安全限制 ；


delegate T MyDele<T>(T a,T b);

static in Add(int x,int y){
return x +y;
}

MyDele<int> myde=new MyDele<int>(Add);
int a= myde(100,200)
return a;

lambda：
1..net framework3.0,是一个匿名方法，是一个语法糖；编译器会生成一个委托调用的方法；
2.不同的lambda 会被编译器生成不同的方法，即使长的一样也会生成不同的方法；

mydelegate mdl=new mydelegate(this.nothing)；
mydelegate mdl=new mydelegate(delegate(string name){
return name;
});

mydelegate mdl=new mydelegate((string name) => {
return name;
})；

//省略类型，编译器自动推算类型
mydelegate mdl=new mydelegate((name) => {
return name;
})；

//如果只有一行，可以省略大括号分号；编译器提供的语法糖，编译器提供的省略功能；
mydelegate mdl=new mydelegate((name) =>
return name)；

//可以省略new mydelegate
mydelegate mdl=(name) =>
return name)；


Action,func 3.0内置的委托；
Action action=()=>Console.write(123); 0--16个参数的没有返回值的委托；
Action<string> act2=s=>{};

Fun<int> f=()=i=>i.tosting(); 0--16个参数的有返回值的委托；

c#6 开始
public string name=>"labmd";
public int id {get;set;}=123;
public string remark
{
get=>"test";
}




Ling:list.where(s=>s.id>100);

Expression:lambda还可以快速声明一个目录树；


Linq高级应用：ling where ，select,是基于委托的代码封装，把数据赛选的通用逻辑完成，把判断交给委托传递；基于委托封装，完成代码复用
把通用的逻辑写好，把可变的逻辑交给委托传递；

Linq to object： --IEnumerable--数据源在内存中-传递的委托判断；

Linq to sql： --数据源在数据库中--需求sql语句--从表达式目录树而来；
Linqtosql表达式目录树来传递和解读；
LinqtoXML
Linqto nosql
Linq to excel
lingq to cache
Linq to Everything


1.基于委托封装，完成代码复用
2.泛型满足不同类型需求
3.静态类+静态方法+第一个参数前加this --扩展方法改进写法：添加
4.IEnumerable迭代器升级，做到了按需获取，延迟加载，提高性能

List<Student> st=LinqExtend.ElevenWhere(studentList,student=>student.age>30);

//1.基于委托的封装，完成代码的复用
//2.泛型满足不同类型的诉求
pubic static List<Student> ElevenWhere(List<Student> studentlist,Func<Student,bool> func)
{
List<Student> sts=new List<Student>();
foreach(var student in studentList)
{
if(func.Invoke(student)){
sts.add（student);
}
}
return sts;
}
//2.泛型满足不同类型的诉求
pubic static List<T> ElevenWhere<T>(List<T> studentlist,Func<T,bool> func)
{
List<T> sts=new List<T>();
foreach(var student in studentList)
{
if(func.Invoke(student)){
sts.add（student);
}
}
return sts;
}

List<Student> st=LinqExtend.ElevenWhere(studentList,student=>student.age>30);
List<int> inlist=LinqExtend.ElevenWhere(intLists,i=>i>100);

//3.扩展方法改进写法：添加 this ，一次性获取所有
pubic static List<T> ElevenWhere<T>(this List<T> studentlist,Func<T,bool> func)
{
List<T> sts=new List<T>();
foreach(var student in studentList)
{
if(func.Invoke(student)){
sts.add（student);
}
}
return sts;
}
//4.迭代器升级：IEnumerable，按需获取用一个拿一个数据，节约性能
IEnumerable<Student> st=studentList.ElevenWhere(student=>student.age>30);
IEnumerable<int> inlist=intLists.ElevenWhere(i=>i>100);


pubic static IEnumerable<T> ElevenWhere<T>(IEnumerable List<T> studentlist,Func<T,bool> func)
{

foreach(var student in studentList)
{
if(func.Invoke(student)){
yieId return student;//sts.add（student);
}
}

}

 

https://www.bilibili.com/video/BV1rT4y1E7LW?p=11