朋友，或许你了解委托，熟悉监视者模式，常用lambda表达式或者linq查询，自定义过扩展方法，但假如你没留意过他们之间的关系，不清楚委托是如何演变为lambda表达式，再如何导出linq语句的，又或者想了解以上知识内容的，那么就进来一起学习本节吧。本节我们要了解委托和监视者模式，然后再由匿名委托一步步导出lambda表达式，最后用lambda表达式结合扩展方法来举例阐释Linq查询。这节是委托到Linq集成化查询的小小推导，希望能对大家有所帮助。本人新手上路，难免纰漏重重，还望大伙儿海涵。更希望大家能提出宝贵意见，鄙人感激不尽。下面咱们就一起探讨学习本节内容吧……
委托：
用Delegate 关键字声明委托，下面要引用MSDN上的一段内容，它们概括出我不能解释的隐含知识：委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的调用可以像其他任何方法一样，具有参数和返回值。委托是一种安全地封装方法的类型，它与 C 和 C++ 中的函数指针类似。与 C 中的函数指针不同，委托是面向对象的、类型安全的和保险的。委托的类型由委托的名称定义。下面的示例声明了一个名为 Del 的委托，该委托可以封装了采用字符串作为参数并返回 void类型 的方法。public delegate void Del(string message); 下面写个委托的例子来帮组大家理解，重点是要理解其中为什么可以把方法名赋值给委托对象。可以参考例子：int a = 0;因为等号左右同为数值类型，类型一致，所以可以赋值。
View Code
1 using System; 2 //这个委托的名字是MyDel,委托的类型是MyDel 3 //这个委托代表了一系列函数，这一些函数必须是没有返回值，没有参数。 4 public delegate void MyDel(); 5 //这个委托代表了一系列函数，这一系列函必须是返回值为String，并且有一个String类型的参数。 6 public delegate void MyDel2(string name); 7 //这个委托代表了一系列函数，这一系列函数必须是返回值为String，并且有一个String类型的参数。 8 public delegate int MyDel3(int a,int b); 9 public class StudyDelegate 10 { 11 public static void Main() 12 { 13 //创建委托对象的两种方法： 14 //1.如果使用new关键字来创建委托对象，则必须使用一个函数初始化这个委托对象。 15 MyDel2 my = new MyDel2(print); 16 //2.如果不使用new关键字来创建委托对象，则可以直接赋值。 17 MyDel2 m1 = print2; 18 //委托和他封装的方法具有相同的功能。 19 //my("ss"); 20 //m1("ww"); 21 //4,既然委托代表了一系列函数，那么一个委托对象可以承接多个函数。 22 my += print2; 23 my("ss"); 24 //在承接的函数集中删减函数 25 my -= print2; 26 my("ss"); 27 28 29 } 30 public static void print(string name) 31 { 32 33 Console.WriteLine("print----------"+name); 34 35 } 36 public static void print2(string n) 37 { 38 Console.WriteLine("2222----------"+n); 39 } 40 41 }
既然我们初步了解了委托，知道委托的定义和形式，那么咱们再一起学习一下委托的常用环境：我举几个简单小例子来引如今天所要说的委托，仔细体会其中的区别：
1.
View Code
1 using System; 2 public class StudyDelegate1 3 { 4 public static void Main() 5 { 6 SayHello("中国"); 7 } 8 public static void SayHello(string county) 9 { 10 if(country=="中国") 11 { 12 Say(content); 13 } 14 if(country=="USA") 15 { 16 Say(content); 17 } 18 if(country=="England") 19 { 20 Say(content); 21 } 22 23 } 24 }
如果有必要加入新的成员国家，则整个程序都要变动，程序健壮性很差。下面我稍加修改：
2.
View Code
1 using System; 2 //相比上面方法，抽象出了枚举 3 public enum Country 4 { 5 中国,American,England,Japan,Koran 6 } 7 public class StudyDelegate1 8 { 9 public static void Main() 10 { 11 SayHello("中国"); 12 } 13 public static void SayHello( Country country,string content) 14 { 15 if(country== Country."中国") 16 { 17 Say(content); 18 } 19 if(country==Country."USA") 20 { 21 Say(content); 22 } 23 if(country==Country."England") 24 { 25 Say(content); 26 } 27 28 } 29 //抽象出了共同的方法体 30 public void Say(string content) 31 { 32 Console.WriteLine(content); 33 } 34 }
加入新的成员国家时候，if语句内容，枚举内容都要更改，健壮性依然很差，下面我用委托知识再稍加修改：
3.
View Code
1 using System; 2 public delegate void DelSay(string content); 3 public class StudyDelegate1 4 { 5 public static void Main() 6 { 7 //采用委托，根据不同国家调用不同内容 8 SayHello("你好",CSay); 9 SayHello("Hello",ESay); 10 11 } 12 //方法主题部分 13 public static void SayHello(string content,DelSay ds) 14 { 15 ds(content); 16 17 } 18 public static void CSay(string content) 19 { 20 Console.WriteLine(content); 21 } 22 public static void ESay(string content) 23 { 24 Console.WriteLine(content); 25 } 26 }
上述委托是当做参数来传递的，传递之后就可以当做方法使用。封装了共同方法，又传入委托做参数来调用方法后，当添加新的成员国家，我们就不必再更改方法的主题部分，相比之上的两个程序，它安全性、可拓展性就好很多。了解了什么是委托了，我们就要来看看什么是监视者模式。
监视者模式：
监视者模式是在微软平台上大量存在的一种模式，通俗一点它就是事件，事件就是监视者模式。比如生活中，你睡觉的时候委托同学上课叫醒你，这就是一个监视者模式，你是被监视者，是委托方，同学是被委托方，监视者。下面给大家举个例子：考试的时候自己委托父母监视自己，考的好的话让父母奖励，考差了则受罚的监视者模式：
View Code
1 using System; 2 public delegate void Del(); 3 4 public class StudyObserver 5 { 6 public static void Main() 7 { 8 //创建对象 9 Student s = new Student(); 10 //Parent pp = new Parent(); 11 //Parent1 pp1 = new Parent1(); 12 13 //s发布两个奖励委托 14 s.p = ()=>{Console.WriteLine("sss");}; 15 s.k =()=>{Console.WriteLine("wwww");}; 16 //s发布两个个惩罚委托 17 //s.k = pp.KKit; 18 //s.k+=pp1.KKit; 19 //s开始执行考试 20 s.Exam(); 21 } 22 } 23 /* 24 发布委托者 25 被监视方、 26 */ 27 public class Student 28 { 29 //声明两个委托变量 30 public Del p = null; 31 public Del k = null; 32 //执行考试（用循环语句模拟考试过程） 33 public void Exam() 34 { 35 for(int i=0;i<=100;i++) 36 { 37 if(i<60) 38 { 39 k(); 40 }else 41 { 42 p(); 43 } 44 } 45 } 46 } 47 /* 48 接受委托方 49 监视方 50 */ 51 public class Parent 52 { 53 //监视者的方法 54 public void PPrice() 55 { 56 Console.WriteLine("考的不错，奖励个馒头"); 57 } 58 public void KKit() 59 { 60 Console.WriteLine("考的太差，面壁思过"); 61 } 62 } 63 /* 64 接受委托方 65 监视方 66 */ 67 //追加的监视者，因为委托可以承接多个函数 68 public class Parent1 69 { 70 public void PPrice() 71 { 72 Console.WriteLine("多奖励一个馒头"); 73 } 74 public void KKit() 75 { 76 Console.WriteLine("考的太差"); 77 } 78 }
平常生活中遇到的监视者模式的例子很多很多，像在visual studio中窗体的button等控件和窗体之间就是监视者模式，当点击button控件时候，不是空间本身字节处理，而是通过form窗体 做出处理（单击button按钮后form窗体来做出反应，弹出对话框）。整个过程不是button自己处理事件，而是button按钮委托form窗体来处理，这时候button就是委托方，form窗体就是监视方。监视者模式其实就是一种委托类型，了解了日常生活中的监视者模式，我们就来看看一种另类的委托------匿名委托…
匿名委托：
匿名委托也是一种委托，只不过没有方法名，可以理解为用delegate代替了匿名委托的方法名，很多情况在不必要创建方法，需要临时创建方法来调用时使用 ，下面例子能很好说明匿名委托的不同用法
View Code
1 using System; 2 public delegate void Delsing(); 3 public delegate int DelPlus(int a, int b); 4 public delegate string DelString(string a, int b); 5 public class StudyDelegate 6 { 7 public static void Main() 8 { 9 //委托 10 Delsing d = Sing; 11 d(); 12 //匿名委托 13 Delsing d1 = delegate(){Console.WriteLine("匿名委托");}; 14 d1(); 15 //带参数且有返回值的匿名委托 16 DelPlus d2 = delegate(int j, int k){return j+k;}; 17 Console.WriteLine(d2(1,2)); 18 //带参数且有返回值的匿名委托，当做参数来传，然后调用函数实现功能 19 DelString d3 = delegate(string a, int b){return a+b;}; 20 Test(d3,"1+1=",2); 21 } 22 public static void Test(DelString del,string a, int b) 23 { 24 string str = del(a,b); 25 Console.WriteLine(str); 26 } 27 public static void Sing() 28 { 29 Console.WriteLine("I'm singing"); 30 } 31 public static void Print() 32 { 33 } 34 35 }
熟悉了匿名委托之后，我们就可以推导lambda表达式了，lambda表达式其实就是匿名委托的‘变种’：
lambda表达式：
lambda表达式其实就是匿名委托精简之后的形式，在参数和方法体中间补上 ‘=>’（称作goes to）来表示这是lambda表达式。下面来看一下lambda表达式具体例子：
View Code
1 using System; 2 public delegate void Delsing(int c); 3 public delegate int DelPlus(int a, int b); 4 public delegate string DelString(string a, int b); 5 public class StudyDelegate 6 { 7 public static void Main() 8 { 9 //匿名函数 10 //Delsing d1 = delegate(int c){Console.WriteLine(c);}; 11 //转化lambda表达式时候要去掉delegate 加上=> 12 //Delsing d1 = (int c)=>{Console.WriteLine(c);}; 13 //一个参数的时候可以去掉括号，不论什么时候参数类型可以省略系统根据委托名自动判断 14 Delsing d1 = c=>{Console.WriteLine(c);}; 15 //函数调用 16 //Test(d1,45); 17 Test(c=>{Console.WriteLine(c);},45); 18 19 /*-----下面委托到lambda表达式的一步步变形同上-------*/ 20 //匿名函数转化为lambda表达式的最初形式 21 DelPlus d2 = (a,b)=>{int c = a+b;return c;} ; 22 //Test(d2,1,2); 23 Test((a,b)=>{int c = a+b;return c;},8,9); 24 //当有返回值，并且直接返回时候，匿名函数中{}可以换做（），并且省略return 25 DelPlus d3 = (a,b)=>(a+b); 26 //调用方法时候，最前面始传的是委托对象，后面是参数 27 //Test(d3,6,5); 28 Test((a,b)=>(a+b),6,7); 29 30 31 DelString d4 = (a,b)=>(a+" "+b); 32 //Test(d4,"h",34); 33 Test((a,b)=>(a+" "+b),"h",45); 34 35 } 36 //函数的重载 37 public static void Test(Delsing d,int a) 38 { 39 d(a); 40 } 41 42 public static void Test(DelPlus d,int a,int b) 43 { 44 int c = d(a,b); 45 Console.WriteLine(c); 46 } 47 public static void Test(DelString d,string a ,int b) 48 { 49 string s = d(a,b); 50 Console.WriteLine(s); 51 } 52 53 }
看了上面例子后，相信你对lambda表达式已有初步印象，下面我做一下lambda表达式不同形式的小总结：
View Code
1 先定义一个Del开头的委托 2 1. public delegate void Del1(); 3 匿名委托 4 Del1 d1 = delegate(){Console.WriteLine("ss");}; 5 d1 = ()=>{Console.WriteLine("ss");}; 6 //由于没有参数，那么()不能省略 7 2.public delegate int Del2(); 8 Del2 d2 = delegate(){return 1;}; 9 d2 = ()=>{return 1;}; 10 //如果是直接返回，换句话说就是没有业务逻辑处理,也就是只有一条返回语句，可以把{}换成()同时去掉return关键字 11 d2=()=>(1); 12 //如果方法体中有业务逻辑，则必须使用{} 13 d2=()=>{if(2>1){return 1;}else{return 2;}}; 14 3.public delegate void Del3(string a); 15 Del3 d3 = delegate(string a){Console.WriteLine(a);}; 16 d3 = (stirng a)=>{Console.WriteLine(a);}; 17 //可以把参数的类型给去掉，因为系统会自行的判断参数的类型，毕竟是把这个lambda赋值给了对应的委托。 18 d3 = (a)=>{Console.WriteLine(a);}; 19 //如果说只有一个参数，则不需要() 20 d3 = a =>{Console.WriteLine(a);}; 21 4.public delegate string Del4(string a); 22 Del4 d4 = delegate(string a){string c = a+78;return c;} 23 d4 = (string a)=>{a+78;return a;}; 24 d4 = a=>{a+78;return a;} 25 d4 = a=>("gg"); 26 5.public delegate int Del5(int a,int b); 27 Del5 d5 = delegate(int a,int b){return a+b;}' 28 d5 = (int a,int b)=>{return a+b;}; 29 d5 = (a,b)=>{return a+b;}; 30 //如果参数个数是大于1的时候，不能把小括号给去掉 31 d5 = (a,b)=>(a+b); 32 d5 = (a,b)=>a+b; 33 d5 = a=>a+1;
lambda表达式的内容就先说到这里，如果大家还要了解更多相关知识，请查看博客园中其他更多有关文章。下面我们小看一下linq
Linq语言集成化查询：
linq不同与结构化查询语言（SQL）它不仅可以查询数据而且可以查询对象。
LINQ 的官方中文名称为“.NET 语言集成查询”，英文全称为 Language-Integrated Query。它提供了类似于 SQL 语法的遍历，筛选与投影功能，LINQ 不仅能完成对于对象的查询，它可以透过 DLINQ 操纵数据库，或是透过 XLINQ 控制 XML.我们来比较下两个不同方法来求出数组中大于20的数据的例子：
1.常用方法：结合上一节讲述的泛型知识，可以把数据放入泛型列表中，再用foreach语句循环输出：
View Code
1 using System; 2 using System.Collections.Generic; 3 public class StudyLinq 4 { 5 public static void Main() 6 { 7 int[] a = {2,23,25,14,1,80,16,26,30}; 8 //求出数组中大于20的数据 9 List<int> list = new List<int>(); 10 foreach(int b in a) 11 { 12 if(b>20) 13 { 14 list.Add(b); 15 } 16 } 17 foreach(int c in list) 18 { 19 Console.WriteLine(c); 20 } 21 } 22 }
2.用IEnumerable的Where扩展方法，通过lambda表达式，精简程序执行过程，需要导入命名空间：using System.Linq;
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyLinq 5 { 6 public static void Main() 7 { 8 int[] a = {2,23,25,14,1,80,16,26,30}; 9 //求出数组中大于20的数据 10 //lambda表达式 11 //var c =a.Where(p=>{return p > 20;}); 12 //化简后 var可以接受任何类型 13 var c =a.Where(p=> p > 20); 14 //Where 返回类型是IEnumerable 15 //IEnumerable<int> c =a.Where(p=> p > 20); 16 foreach(int i in c) 17 { 18 Console.WriteLine(i); 19 } 20 21 } 22 }
上面可以算作小的linq查询，但能算真正的linq，我暂时理解为广义的linq。 例子中(p=> p > 20)其实就是个lambda表达式，是微软定义好的一个委托，从这个委托的特点我们知道它有一个参数，返回值是bool类型。数组肯定实现了IEnumerable接口，而Where是IEnumerable<(Of <(T>)>) 成员 的一个扩展方法，MSDN中定义为 Where(Func<(Of <(UMP, Boolean>)>)) 基于谓词筛选值序列。 （由 Enumerable 定义。）
public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, bool> predicate
)
public delegate TResult Func<T, TResult>(
T arg
)
结合本例子上面两句则可以删减为以下两种形式：
public delegate bool Func(T arg)
Func = p=>{return p > 10;};
p=>()p>10
p=>p>10
上面的三个lambda其实是等效的，实现的一个功能
public static IEnumerable Where(Func<TSource, bool> predicate)
linq查询语句就是利用微软定义好的方法，执行一定条件的查询语句。（好像表达的不够明白，下面再做一个例子来说明，希望能帮组大家理解）：
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyLinq 5 { 6 public static void Main() 7 { 8 List<Student> list = new List<Student>(); 9 list.Add(new Student(){Age=10,Name="Jack"}); 10 list.Add(new Student(){Age=67,Name="Mack"}); 11 list.Add(new Student(){Age=23,Name="Dack"}); 12 list.Add(new Student(){Age=56,Name="Cack"}); 13 list.Add(new Student(){Age=8,Name="Eack"}); 14 list.Add(new Student(){Age=34,Name="Hack"}); 15 list.Add(new Student(){Age=18,Name="小红"}); 16 //查询出结合中年龄大于45的学生 17 Func<Student,bool> f = p=>p.Age>45; 18 IEnumerable<Student> result = list.Where<Student>(f); 19 foreach(Student s in result) 20 { 21 Console.WriteLine(s.Age+" "+s.Name); 22 } 23 //查询出集合中年令小于30的，并且名字已E得学生 24 var result1 = list.Where(p=>p.Age<30 && p.Name.StartsWith("E")); 25 foreach(Student s in result1) 26 { 27 Console.WriteLine(s.Age+" "+s.Name); 28 } 29 30 } 31 32 } 33 public class Student 34 { 35 public int Age 36 { 37 get; 38 set; 39 } 40 public string Name 41 { 42 get;set; 43 } 44 }
linq查询调用了微软定义好的扩展方法进行查询，下面我们插入一段扩展方法的内容，帮助理解上面linq中的Where扩展方法。
扩展方法：
通俗点说就是在不更改原来类的基础山，为类添加方法。需要注意的是：1，扩展方法必须写静态类中。 2，扩展方法必须是静态方法，虽然是静态方法，但是这个扩张方法是为对象扩展的，只能由对象调用。它的定义是：
public static class 类名
{
public static 返回值 方法名(this 要扩展的类型 对象名[,参数列表])
{
}
}
我们来做三个扩展方法，1.为string类扩展个获取文件类型的方法。2.为自定义的People类扩展一个看时间的方法。3.扩展一个获取姓名的方法，下面我们一起来看看：
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyExtendMethod 5 { 6 public static void Main() 7 { 8 //调用扩展方法获取文件类型 9 string file = @"E:\FTPPUBLISH\学习资料\KindEditor\kindeditor-v4.0.3\examples\colorpicker.html"; 10 Console.WriteLine(file.GetFileType()); 11 string sss = "78.9.09.mp3"; 12 Console.WriteLine(sss.GetFileType()); 13 //调用扩展方法获取时间 14 People pp = new People(); 15 pp.WatchTime("www"); 16 //获取信息 17 string od = pp.GetInfo("张三"); 18 Console.WriteLine(od); 19 //为IEnumerable扩展获取IEnumerable<int>中前十个元素的方法 20 List<int> list = new List<int>(); 21 list.Add(1); 22 list.Add(19); 23 list.Add(34); 24 list.Add(56); 25 list.Add(2); 26 list.Add(90); 27 list.Add(23); 28 list.Add(27); 29 var c = list.GetBigTen(10); 30 foreach(int d in c) 31 { 32 Console.WriteLine(d); 33 } 34 35 } 36 } 37 public static class ExtendMethod 38 { 39 /* 40 this string ss 41 这个参数只起到一个说明性作用。 42 这个扩展方法是为string的对象扩展的，只能有string的对象来使用 43 str值得是使用这个扩展方的对象。 44 */ 45 public static string GetFileType(this string str) 46 { 47 string[] strs = str.Split('.'); 48 return strs[strs.Length-1]; 49 } 50 //this People p说明这个扩展方法是为people对象扩展的，只能由People对象调用 51 public static void WatchTime(this People p,string name) 52 { 53 Console.WriteLine(name +" "+DateTime.Now); 54 } 55 public static string GetInfo(this People p,string name) 56 { 57 return name+"sssss"; 58 } 59 public static IEnumerable<int> GetBigTen(this List<int> list,int a) 60 { 61 return list.Where(p=>p>a); 62 } 63 64 } 65 public class People 66 { 67 68 }
理解了这些扩展方法，相信会有助于你理解上面linq查询时所用的Where扩展方法。下面我们继续来看linq查询，把上面的linq再做一步扩展：
用linq语句进行查询，并将结果降序分组排列的三种方法
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyLinq 5 { 6 public static void Main() 7 { 8 List<Student> list = new List<Student>(); 9 list.Add(new Student(){Age=10,Name="Jack",Address="bj"}); 10 list.Add(new Student(){Age=67,Name="Mack",Address="郑州"}); 11 list.Add(new Student(){Age=23,Name="Dack",Address="USA"}); 12 list.Add(new Student(){Age=56,Name="Cack",Address="bj"}); 13 list.Add(new Student(){Age=8,Name="Eack",Address="郑州"}); 14 list.Add(new Student(){Age=34,Name="Hack",Address="bj"}); 15 list.Add(new Student(){Age=18,Name="小红",Address="USA"}); 16 //查询出结合中年龄大于45的学生（完整的形式，一般不这样写） 17 Func<Student,bool> f = p=>p.Age>45; 18 IEnumerable<Student> result = list.Where<Student>(f); 19 foreach(Student s in result) 20 { 21 Console.WriteLine(s.Age+" "+s.Name); 22 } 23 //查询出集合中年令小于30的，并按年龄降序排列，并按城市分组 24 //第一种方法 25 IEnumerable<Student> result1 = list.Where(p=>p.Age<30).OrderByDescending(p=>p.Age); 26 27 foreach(Student s in result1) 28 { 29 Console.WriteLine(s.Age + " "+s.Name); 30 } 31 IEnumerable<IGrouping<string,Student>> result2 = result1.GroupBy<Student,string>(p=>p.Address); 32 33 foreach(IGrouping<string,Student> gg in result2) 34 { 35 foreach(Student s in gg) 36 { 37 Console.WriteLine(s.Age + " "+s.Name+" "+s.Address); 38 } 39 } 40 41 42 43 44 45 /*分组的第二种方法 46 var result1 = list.Where(p=>p.Age<30).OrderByDescending(p=>p.Age).GroupBy(p=>p.Address); 47 var c = result1.GetEnumerator(); 48 while(c.MoveNext()) 49 { 50 var d = c.Current.GetEnumerator(); 51 52 while(d.MoveNext()) 53 { 54 Console.WriteLine(d.Current.Name+" "+d.Current.Address); 55 } 56 57 }*/ 58 /*分组的第三种方法 59 var result1 = list.Where(p=>p.Age<30).OrderByDescending(p=>p.Age); 60 var result2 = from p in result1 group p by p.Address; 61 foreach(Student s in result1) 62 { 63 Console.WriteLine( s.Age + " "+s.Name+" "+s.Address); 64 }*/ 65 66 } 67 68 } 69 public class Student 70 { 71 public int Age 72 { 73 get; 74 set; 75 } 76 public string Name 77 { 78 get;set; 79 } 80 public string Address 81 {get;set;} 82 }
理解了上面例子的查询过程，你就掌握了基本的linq查询了。仔细领会其执行顺序，要理清各语句关系。
再做两个小例子，这是我理解的完全的linq查询：
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyLinq3 5 { 6 public static void Main() 7 { 8 9 List<Student> list = new List<Student>(); 10 list.Add(new Student(){Age=10,Name="Jack",Address="bj"}); 11 list.Add(new Student(){Age=67,Name="Mack",Address="郑州"}); 12 list.Add(new Student(){Age=23,Name="Dack",Address="USA"}); 13 list.Add(new Student(){Age=56,Name="Cack",Address="bj"}); 14 list.Add(new Student(){Age=8,Name="Eack",Address="郑州"}); 15 list.Add(new Student(){Age=34,Name="Hack",Address="bj"}); 16 list.Add(new Student(){Age=18,Name="小红",Address="USA"}); 17 IEnumerable<IGrouping<string,Student>> result = from p in list 18 where p.Age > 30 19 orderby p.Age ascending 20 group p by p.Address; 21 // select p; 22 foreach(IGrouping<string,Student> s in result) 23 { 24 foreach(Student ss in s) 25 { 26 Console.WriteLine(ss.Age +" "+ss.Address); 27 } 28 } 29 30 /*用前面讲到的扩展方法来查询长度大于三的元素 31 string[] str = {"a","bb","abc","中华民谣","USA"}; 32 33 IEnumerable<string> result = from p in str 34 where p.Length>3 35 select p; 36 foreach(string s in result) 37 { 38 Console.WriteLine(s); 39 } 40 41 42 IEnumerable<string> result = str.Where<string>(p=>p.Length>3); 43 foreach(string s in result) 44 { 45 Console.WriteLine(s); 46 }*/ 47 } 48 } 49 50 public class Student 51 { 52 public int Age 53 { 54 get; 55 set; 56 } 57 public string Name 58 { 59 get;set; 60 } 61 public string Address 62 {get;set;} 63 }
View Code
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 public class StudyLinq3 5 { 6 public static void Main() 7 { 8 9 List<Student> list = new List<Student>(); 10 list.Add(new Student(){Age=10,Name="Jack",Address="bj"}); 11 list.Add(new Student(){Age=67,Name="Mack",Address="郑州"}); 12 list.Add(new Student(){Age=23,Name="Dack",Address="USA"}); 13 list.Add(new Student(){Age=56,Name="Cack",Address="bj"}); 14 list.Add(new Student(){Age=8,Name="Eack",Address="郑州"}); 15 list.Add(new Student(){Age=34,Name="Hack",Address="bj"}); 16 list.Add(new Student(){Age=18,Name="小红",Address="USA"}); 17 var result = ( from p in list 18 where p.Age >30 19 select p).OrderByDescending(pp=>pp.Age); 20 21 foreach(Student s in result) 22 { 23 Console.WriteLine(s.Age); 24 } 25 26 } 27 } 28 29 public class Student 30 { 31 public int Age 32 { 33 get; 34 set; 35 } 36 public string Name 37 { 38 get;set; 39 } 40 public string Address 41 {get;set;} 42 }
最后我们做个小小的linq总结：Linq语言集成化查询基础是泛型和lambda表达式他的形式是：
from 元素 in 集合
where 元素条件
orderby 元素.属性 ascending
group 元素 by 元素.属性
select 元素
和SQL查询很类似，上面例子中以表明如果使用group by语句，则不需要select。
非常感谢大家腾出宝贵时间来阅读本节，本节的讲解很凌乱，如果有表达不明确之处，希望咱们私下能认真交流，共同学习。新手上路，大家多多关照…………
571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
