关闭

Linq to Object

664人阅读 评论(0) 收藏 举报

Linq简介:

Linq(集成查询语言),好东西啊,又是微软退出的一款重量级的软件设计解决方案。推出至今已有2年多了,刚推出的时候没多大关注它,最近才开始学习它。通过它来写软件能明显提高软件的开发效率。相恨见晚啊!!!

Linq这个语言体系主要为4大部分:

u     Linq to Object

u     Linq to Xml

u     Linq to Ado.Net

u     Linq to Sql

先来说说Linq To Object吧。在如今这样的软件世界里,大家都采用面向对象的编程方法设计软件,在这个对象满天飞的软件世界里,我们急需一个超人。咱们只要告诉他咱们需要什么,一切的过程都由他去搞定。咱们就安逸的等着他来给咋们汇报结果就可以了。哈哈,在.Net的世界里,咱们的超人诞生了----Linq。

现在咱就来领教下超人的本领吧。

初窥Linq

案例1:如何在一串字符串中找到咱们的敌人。

废话不多说,看代码:

  1. String text=”hello everyone im a boy,do you love me?”; 
  2.  
  3. String[] data=text.split(‘ ‘); 
  4.  
  5. Var result=from s in data 
  6.  
  7.          Where s==”boy” 
  8.  
  9.          Select s; 
  10.  
  11. Console.WriteLine(s); 
  12.  
  13. 结果为:boy    
     

会Sql语句的朋友对这段代码应该会相当的敏感,里面的Linq关键字“from”,“where”,“select”依然沿用了Sql语句中的关键字。只是在Linq语句中将“select”关键字放到了最后。

返回类型为“var”,这东西是啥啊,其实它和javascript里面的var一样,定义的是弱类型。

看看这句“from s in data” 可以理解为从记录集合data中取一条记录把它保存在临时变量s中。

然后就是这句”where s==”boy” ”可以理解为如果临时变量s中的值为“boy”的话那就选择它。呵呵,学过sql语句的人都懂的。

最后就是这句了“select s”,可以理解为如果前面的“where”关键字后面跟随的条件为真的话就返回这条记录,如果为假就不返回。

案例1中的代码就是Linq to Object的一个缩影,回头看看是不是里面参与计算的内容都是对象呢,其实你只要把这里的对象想像成数据库中的记录就好理解啦。

案例2:如何在一串字符串里面,找出所有以字母“b”开头的字母

  1.   String text=”book boy apple orange banana”; 
  2.  
  3.   String[] data=text.splict(‘ ’); 
  4.  
  5.   Var result=from s in data 
  6.  
  7.            Where s.StartsWith(“b”) 
  8.  
  9.            Select s; 
  10.  
  11.   Foreach(string s in result) 
  12.  
  13.         Console.WriteLine(s+”/n”); 
  14.  
  15. 结果为; 
  16.  
  17. book 
  18.  
  19.       boy 
 

在Linq To Object里面,对象的方法也是可以进行调用的。

案例1改进版:

咱假设有个类

  1. Class Text 
  2.  
  3.  
  4.     Private string _data=”hello everyone im a boy,do you love me?”; 
  5.  
  6. Public string[] getData() 
  7.  
  8.  
  9.     Return _data.splict(‘ ‘); 
  10.  
  11.  
  12.  
  13. Text myText=new Text(); 
  14.  
  15. Var result=from s in myText.getData() 
  16.  
  17.          Where s==”boby” 
  18.  
  19.          Select s; 
  20.  
  21. 结果依然为:boy 

待查询的结果集也可以调用对象的方法动态生成。

案例3:返回匿名的对象集合

  1. String text=”hello everyone im a boy,do you love me?”; 
  2.  
  3. String[] data=text.split(‘ ‘); 
  4.  
  5. Var result=from s in data 
  6.  
  7.          Where s==”boy” 
  8.  
  9.          Select new{ 
  10.  
  11.                  Data=s, 
  12.  
  13.                  DateTime=DateTime.Now.ToString() 
  14.  
  15.  
  16.  
  17. Console.WriteLine(“{0}  {1}”,s.Data,s.DateTime); 
  18.  
  19. 为:boy  ****年**月**日***等。 

返回的结果为一个匿名对象啦,如下的构造方法,有点像json的声明方法。

new{

                  Data=s,

                  DateTime=DateTime.Now.ToString()

}

案例4:中间值”let”的使用

  1.   Int[] data=new Int[]{1,2,3,4,5,6,7,8,9,10}; 
  2.  
  3.   Var result=from d in data 
  4.  
  5.            Let tmp=d%2 
  6.  
  7.            Where tmp==0 
  8.  
  9.            Select d; 
  10.  
  11.   Foreach(int s in result) 
  12.  
  13.         Console.WriteLine(s+”/n”); 
  14.  
  15. 结果为: 
  16.  
  17. 2, 
  18.  
  19.  
  20.  
  21.  
  22. 10 

  该查询中,let充当中间缓存作用,如果当Linq语句结构十分庞大的时候,使用let可以让咋们的Linq语句结构更加清晰。

案例5:排序“orderby”,”ascending”,”descending”的使用

  1.   String[] data={“Orange”,”Open”,”Apple”,”Any”,”Bus”,”Bank”}; 
  2.  
  3.   Var result=from s in data 
  4.  
  5.            Orderby s.SubString(0,1) ascending,s.SubString(1,1) 
  6.  
  7.            Select s; 
  8.  
  9.    Foreach(int s in result) 
  10.  
  11.         Console.WriteLine(s+”/n”); 
  12.  
  13. 结果为: 
  14.  
  15. Apple 
  16.  
  17. Any 
  18.  
  19. Bank 
  20.  
  21. Bus 
  22.  
  23. Open 
  24.  
  25. Orange 

关键字“OrderBy”后面跟了两个排序条件“Orderby s.SubString(0,1)”,“s.SubString(1,1)”:一个是根据第一个字母进行排序,另一个是根据第二个字母进行排序。紧跟关键字“OrderBy”后面的是主要排序条件,先对它进行排序。紧跟其后的都为次要排序条件,都是在不改变其前面的排序情况下来进行排序。”ascending”升序,”descending”降序,默认排序方式为升序。

案例6:分组“group”的使用

  1.   String[] data={“Orange”,”Open”,”Apple”,”Any”,”Bus”,”Bank”}; 
  2.  
  3.   Var result=from s in data 
  4.  
  5.            Group s by s.SubString(0,1) into groupname 
  6.  
  7.            Orderby groupname.key 
  8.  
  9.            Select new{ 
  10.  
  11.                 GroupName=”以”+groupname.key+”开头的单词”, 
  12.  
  13.                 Count=groupname.Count() 
  14.  
  15. }; 
  16.  
  17.    Foreach(vart s in result) 
  18.  
  19.         Console.WriteLine(”{0}   {1}/n”,s.GroupName,s.Count); 
  20.  
  21. 结果为: 
  22.  
  23. 以A开头的单词 2 
  24.  
  25. 以B开头的单词 2 
  26.  
  27. 以O开头的单词 2 

  “Group s by s.SubString(0,1) into groupname”意思为:对s进行分组,分组的依据为“s.SubString(0,1)”方法返回的结果。并将该小组暂时保持到临时变量groupname中。其中”groupname.key”获取的东西是“s.SubString(0,1)”方法返回的结果。”Groupname.Count()”中的Count()方法是聚合函数。

案例7:如何连接两个结果集合进行联合查询,关键字“join”

  1. String[] name=new String[]{“Jim Green”,”Any White”,”Tim Brown”}; 
  2.  
  3. String[] telphone=new String[]{“Green 13576090876”, 
  4.  
  5. ”White 15807088100”, 
  6.  
  7. ”Brown 13868776544”} 
  8.  
  9. 数组name和数组telphone是有联系的,下面咱们来根据姓名来查询电话号码。 
  10.  
  11. Var result=from n in name 
  12.  
  13.           Let familyName=n.splict(‘ ‘)[1] 
  14.  
  15.          Join t in telphone on familyName equals t.splict(‘ ‘)[0] 
  16.  
  17.          Where n=”Jim Green” 
  18.  
  19.         Select t.splict(‘ ‘)[1]; 
  20.  
  21.    Foreach(vart s in result) 
  22.  
  23.         Console.WriteLine(result); 
  24.  
  25. 结果为: 
  26.  
  27. 13576090876 

数组name和数组telphone之间存在“家庭名称相等”的关系,咱们利用这个关系对这两个数组进行连接查询。

案例8:如何通过笛卡尔积得形式获取案例7中同样的效果。

废话不多说,看代码:

  1. Var result=from n in name 
  2.  
  3.            From t in telphone 
  4.  
  5.             Let tmpN=n.splict(‘ ‘)[1] 
  6.  
  7.              Let tmpT=t.splict(‘ ‘)[0] 
  8.  
  9.               Where tmpN=tmpT && n==”Jim Green” 
  10.  
  11.                 Select t.splict(‘ ‘)[1] 
  12.  
  13.    Foreach(vart s in result) 
  14.  
  15.         Console.WriteLine(result); 
  16.  
  17. 结果为: 
  18.  
  19. 13576090876 

  这个查询就没有使用“join”关键字。但是它也能解决问题。

通过上面8个案例,咱们对Linq有了个总体的认识,现在咱们再来具体的研究下它的其他高级功能。

Linq中的聚合函数:

Average求平均值函数

Count求总量

LongCount求总量,返回值为long型

Max求最大值

Min求最小值

Sum求和

Linq中对返回的结果集合进行操作:

啥为结果集合呢?案例1返回的结果在这里就可以称为结果集合。

现在咱们要将案例1返回的结果集合A和案例2返回的结果集合B进行集合操作。集合操作一共分为4种:

交集(关键字“Intersect”)

Var交集结果=集合A.Intersect(集合B)

用法就像调用方法样的

并集(关键字“Union”)

差集(关键字“Except”)

去重复(关键字“distinct”)

Linq中Where子句的过滤关键字

All

Bool value=集合A.All(“book”,”bank”,”bomb”)

当集合A包含“book”,”bank”,”bomb”这些字符串时返回为true,否则都为false

Any

Bool value=集合A.Any(“book”,”bank”,”bomb”)

当集合A包含“book”或”bank”或”bomb”这些字符串得一个或以个以上就返回true,都不包含就返回false

Contains

Bool value=集合A.Contains(“book”)

当集合A包含“book”就返回true,不包含就返回false

Linq中的数据分区关键字

Skip

假设有个集合A,里面包含10条记录。现在这条代码:集合A.Skip(3)表示跳过前面3条记录,直接从第4条开始获取。

SkipWhile

功能与Skip类似,集合A.SkipWhile(a=>a.length>5).表示从第一条数据开始进行检查,如果该数据长度小于5就跳过,如果大于5就从该数据开始一直获取到尾。

Take

假设有个集合A,里面包含10条记录。现在这条代码:集合A.Take(3)表示只获取前面3条记录。

TakeWhile

功能与Skip类似,集合A.TakeWhile(a=>a.length>5).表示从第一条数据开始进行检查,如果该数据长度小于5就获取,如果大于5就终止获取。

Linq中将返回的结果集合转换为其他呈递类型的关键字

AsEnumerable

将结果集合转换为Ienumerable<T>泛型类型

AsQueryable

将结果集合转换为Iqueryable<T>泛型类型

Cast

OfType

ToArray

将结果集合转换为数组

ToDictionary

将结果集合转换为字典

ToList

将结果集合转换为列表

ToLookup

Linq中返回结果集合中的某个记录

ElementAt

ElementAt(2)则为返回第2个记录

ElementAtOrDefault

与ElementAt功能类似,只不过当给予的下标越界是将会返回默认的记录

First

第一条记录

FirstOrDefault

Last

最后一天记录

LastOrDefault

Single

SingleOrDefault

 http://blog.csdn.net/ghostbear/article/details/6192989

Linq中的Lambada表达式

废话不多说,看下面的代码

String[] data=new string[]{“Apple”,”Book”,”Banana”,”Orange”};

Var result=data.where(a=>a.SubString(0,1)==”A”);

Foreach(string s in result)

Console.WriteLine(s);

结果为:

Apple

上面是带一个参数的lambada表达式,下面在整个带2参数的lambada表达式

String[] data=new string[]{“Apple”,”Book”,”Banana”,”Orange”};

Var result=data.where((a,i)=>a.SubString(0,1)==”B”&&i>1);

Foreach(string s in result)

Console.WriteLine(s);

结果为:

Banana

第二个参数“i“为系统内置的参数,标示的是当前记录在数组集合中的下标

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:155853次
    • 积分:1849
    • 等级:
    • 排名:千里之外
    • 原创:24篇
    • 转载:65篇
    • 译文:0篇
    • 评论:26条