DDWiki

鼎鼎知识库

Linq概述

Linq(语言集成查询)在C#中集成了查询语法，可以用相同的语法访问不同的数据源。Linq提供了不同数据源的抽象层，所以可以使用相同的语法。

标准的查询操作符

Where OffType

筛选操作符定义了返回元素的条件。在Where查询操作符中可以使用谓词。例如，lambda表达式定义的谓词，来返回布尔值。OfType根据类型筛选元素，只返回TResult类型的元素

Select SelectMany

投射操作符用于把对象转换为另一个类型的新对象。Select和SelectMany定义了根据选择器函数选择结果值得投射

OrderBy\ThenBy\OrderByDescending\ThenByDescending\ThenByDescending\Reverse

排序操作符改变所返回的元素的顺序。OrderBy按升序排序，OrderByDescending按降序排序。如果第一次排序的结果很类似，就可以使用ThenBy和ThenBy Deacending 操作符进行第二次排序。Reverse反转集合中元素的顺序

Join\GroupJoin -连接操作符用于合并并不直接相关的集合。使用Join操作符，可以根据键选择器函数连接两个集合，这个类似于SQL中的JOIN。GroupJoin操作符连接两个集合，组合其结果
GroupBy\ToLookup
- 组合操作符把数据放在组中。GroupBy操作符组合有公共键的元素。ToLookup通过创建一个一对多字典，来组合元素
Any\All\Contains
- 如果元素序列满足指定的条件，限定符操作符就返回布尔值。Any确定集合中是否有满足为此函数的元素；All确定集合中的所有元素是否都满足谓词函数；Contains检查某个元素是否在集合中
Take\Skip\TakeWhile\SkipWhile
- 分区操作符返回集合的一个子集。Take、Skip、TakeWhile和SkipWhile都是分区操作符。使用它们可以得到部分结果。使用Take必须指定要从集合中提取的元素个数；Skip跳过指定的元素个数，提取其他元素；TakeWhile提取条件为真的元素，SkipWhile跳过条件为真的元素。
Distinct\Union\Intersect\Except\Zip
- Set操作符返回一个集合。Distinct从集合中删除重复的元素，除了Distinct之外，其他Set操作符都需要两个集合。Union返回出现在其中一个集合中的唯一元素。Intersect返回两个集合中都有的元素。Except返回只出现在一个集合中的元素。Zip把两个集合合并为一个。
First\FirstOrDefault\Last\LastOrDefault\ElementAt\ElementAtOrDefault\Single\SingleOrDefault
- 这些元素操作符仅返回一个元素。First返回第一个满足条件的元素。FirstOrDefault类似于First，但如果没有找到满足条件的元素，就返回类型的默认值。Last返回最后一个满足条件的元素。ElemAt指定了要返回的元素的位置。Single只返回一个满足条件的元素。如果有多个元素都满足条件，就抛出一个异常。所有的XXOrDefault方法都类似与以相同前缀开头的方法，但如果没有找到该元素，他们就返回类型的默认值
Count\Sum\Min\Max\Average\Aggregate
- 聚合操作符计算集合的一个值。利用这些聚合操作福，可以计算所有值得总和、所有元素的个数、值最大和最小的元素，以及平均值等
ToArray\AsEnumerable\ToList\ToDictionary\Cast
- 这些转换操作符将集合转换为数组：IEnumerable、IList、IDictionary等。Cast方法把集合的每个元素类型转换为泛型参数类型
Empty\Range\Repeat
- 这些生成操作符返回一个心机和。使用Empty时集合时空的：Range返回一系列数字：Repeat返回一个始终重复一个值得集合

筛选

使用where子句，可以合并多个表达式。例如，找出赢得至少15场比赛的巴西和奥地利赛车手。 ``` var racers = from r in Formulal.GetChampions()where r.Wins> 15 &&(r.Country==“Brazil” || r.Country=“Austria”) select r;

foreach(var r in rqacers) {

WriteLine($"{r:A}");

}

var racers=Formulal.GetChampions().Where(r=>r.Wins>15 &&(r.Country==“Brazil” || r.Country== “Austria”)).Select(r=>r);

> 用索引筛选
- 不能使用Linq查询的一个例子是Where()方法的重载。在Where()方法的重载中，可以传递第二个参数--索引。索引是筛选器返回的每个结果的计数器。可以在表达式中使用这个索引，执行基于索引的计算。

var racers =Formulal.GetChamplons().Where((r,index)=>r.LastName.StartsWith(“A”) && index%2!=0); foreach (var r in racers) {

WriteLine(${r:A});

}


> 类型筛选

-为了基于类型的筛选，可以使用OfType()扩展方法。这里数组数据包含string和int对象。使用OfType()扩展方法，把string类传送给泛型参数，就从集合中仅返回字符串

object[] data={“one”,2,3,“four”,“five”,6}; var query=data.OfType(); foreach(var s in query) { WriteLine(s);
}



> LINQ查询中的变量

- 在为分组编写的LINQ查询中，Count方法调用了多次。使用了let子句可以改变这种方式。let允许在LINQ查询中定义变量：

var countries=Formulal.GetChampions().GroupBy(r=>r.Country).Select(g=>new{Group=g,Count=g.Count()}).OrderByDescending(g=>g.Count).ThenBy(g=>g.Group.Key).Where(g=>g.Count>=2).Select(g=>new {

Country=g.Group.Key,
Count=g.Count

});


> 内连接
- 使用join子句可以根据特定的条件合并两个数据源，但之前要获得两个要连接的列表。
- 例子：在一级方程式比赛中，有赛车手冠军和车队冠军。赛车手从GetChampions()方法中返回，车队从GetConstructorChampions()方法中返回。现在要获得一个年份表，列出每年的赛车手冠军和车队冠军
    - 先定义两个查询，用于查询赛车手和车队
     ```
     var racers=from r in Formulal.GetChampions() from y in r.Years select new
     {
         Year=y,
         Name=r.FirstName+""+r.LastName
     };
     var teams=from t in Formulal.GetContructorChampions() from y in t.Years select new
     {
         Year =y,
         Name=t.Name
     };
     ```
    - 有了这两个查询，再通过join子句，根据赛车手获得冠军的年份和车队获得冠军的年年份进行连接。select子句定义了一个新的匿名类型，它包含Year、Racer和Team属性。
     ```
     var racersAndTeams=(from r in racers join t in teams on r.Year equals t.Year select new
     {
         r.Year,
         Champion=r.Name,
         Constructor=t.Name
     }).Take(10);
     WriteLine("Year World Champion\t Constructor Title");
     foreach (var item in racersAndTeams)
     {
         WriteLine($"{item.Year}:{item.Champion,-20}{item.Constructor}");
     }
     也可以把它们合并为一个LINQ查询
     var racersAndTeams=
     {
         from r in 
         from r1 in Formulal.GetChampions()
         from yr in r1.Years
         select new
         {
             Year=yr,
             Name=r1.FirstName + "" +r1.LastName
         }
         join t in
         from t1 in Formulal.GetContructorChampios()
           from yt in t1.Years select new
           {
               Year=yt,
               Name=t1.Name
           }
           on r.Year equals t.Year
           orderby new
           {
               Year=r.Year,
               Racer=r.Name,
               Team=t.Name
           }).Take(10);

     }
     ```

> 左外连接
- 左外连接用join子句和DefaultIfEmpty方法定义。

var racersAndTeams= (from r in racers join t in teams on r.Year equals t.Year into rt from t in rt.DefaultIfEmpty() orderby r.Year select new {

Year=r.Year,
Champion=r.Name,
Constructor=t==null?"no constructor championship":t.Name

}).Take(10);


> 组连接

- 左外连接使用了组连接和into子句。它有一部分语法与组连接相同，只不过组连接不使用DefaultIfEmpty方法。
- 使用组连接时，可以连接两个独立的序列，对于其中一个序列中的某个元素，另一个序列中在对应的一个项列表。

> 集合操作
- 扩展方法Distinct(),Union(),Intersect(),Except()都是集合操作。
- 集合操作通过调用实体类的GetHashCode()和Equals()方法来比较对象。对于自定义比较，还可以传递一个实现了IEqualityComparer<T>接口的对象。


> 合并
- Zip()方法允许用一个谓词函数把两个相关的序列合并为一个。

var racerNames=from r in Formulal.GetChampions() where r.Country==“Italy” orderby r.Wins descending select new {

Name=r.FiretName+""+r.LastName

}; var racerNamesAndStarts=from r in Formulal.GetChampions() where r.Country==“Italy” orderby r.Wins descending select new {

LastName=r.LastName,
Starts=r.Starts

};

var races=racerName.Zip(racerNamesAndStarts, (first,second)=>first.Name+“,starts:”+second.Starts) foreach(var r in racers) {

WriteLine(r);

} ```

7.Linq.md 8.7KB Raw Blame 履歴

7.Linq.md 8.7KB

Raw Blame 履歴