LINQ语句小结



                               

筛选 Where

Where可以合并多个表达式，传给Where表达式结果应该是bool型

示例：

var racers =

from r in Formula1.GetChampions()

where r.Wins>15 && (r.Country==”Chinese” ||(r.Counrty==”Austria”))

select r;

扩展方法：

Var racers=Formula1.GetChampions().Where(r=>r.Wins>15&&(r.Country==”Chinese” ||(r.Counrty==”Austria”))).Select(r=>r);       

索引筛选Where(r,index)扩展方法

将原对象的每个元素的index(zerp-based)传到表达式中，但没有对应的LINQ语句

(The second argument represents the zero-based index of the element within source).

示例：

Var racers=Formula1.GetChampions().Where((r,index)=>r.lastname.StartWith(“A”)&&index%2!=0)

类型筛选

OfType()扩展方法

示例：

Object[] data={“one”, 2, 3, “four”};

Var query =data.OfType<string>();

复合的from子句

如果序列的成员也是一个序列（比如List<T>的成员也是一个List<T>），则使用复合from子句。

示例：

from r in Formula1.GetChampions()

from c in r.Cars

where c==”Ferrari”

orderby r.lastName

select r.FirstName + “ ” + r.LastName;

from复合子句解析成SelectMany()扩展方法

排序

LINQ语法

单一排序：orderby XXXdescending/ascending(缺省默认)

多条件排序：orderby xxxdescending, xxxdescending, xxxascending…

示例：

Var racers = from r in Formula1.GetChampins()

         where r.Country == “Brazil”

         orderby r.Wins descending

         select r;

扩展方法：

orderby xxx ascending=> OrderBy()

orderby xxx descending=>OrderByDescending()

orderby xxx descending, xxx descending, xxx ascending=>

OrderByDescending().ThenByDescending().ThenBy()

分组

group xxx by xxx into xxx把查询结果分一个一个组。

 

示例：

Var countries=from r in Formula1.GetChanpions()

group rby r.Countryinto g

orderby g.Count() descending, g.Key

where g.Count()>=2

select new

{

 Country =g.Key;

 Count =g.Count();

};

//分组名为IGrouping接口，可调用g.Count(), g.Key等方法和属性。

 

扩展方法：

group查询语句对应的扩展方法为GroupBy().

Var countries =Formula1.GetChampions().GroupBy(r=>r.Country)

.OrderByDescending(g=>g.Count).ThenBy(g=>g.Key).Where(g=>g.Count()>=2).Select(g=>new {Country=g.Country,Count=g.Count()});

对嵌套的对象分组

如果想获得分组结果中的某个序列，比如同一个国家的赛车手序列，则需要在select子句里使用from子句再次进行查询。

示例：

Var countries=from r in Formula1.GetChampions()

group r by r.Country into g

orderby g.Count() descending, g.Key where g.Count()>=2

select new

{

Country=g.Key,

Count=g.Count(),

Racers=from r1 in g

      orderby r1.LastName

      select r1.FirstName+” ”+r1.LastName

};

内连接

即合并满足条件（交集）的两个数据源，生成新的序列

Join xxx in xxx on xxx equals xxx

示例：每一年的车手冠军和车队冠军

var racersAndTeams=from r in racers

                 join t in teamson t.yearequals r.year

                 select new

{

Year = r.year,

Champion=r.Name,

Constructor=t.Name

};

左外连接

合并两个数据源，但包含左边序列的全部元素，即使右边序列中没有匹配的元素。

示例：

Var racersandTeams=from r in racers

                 join tin teamson r.year equals t.yearinto rt

from t inrt.DefaultIfEmpty()

orderby r.year

select new

{

Year = r.year,

Champion=r.Name,

Constructor=t==null?”no constructor championship”:t.Name

}

组连接

即满足条件的所有的第二个集合（join那个）元素添加到into那个变量中，这样第一个集合（from那个）就可以包含满足条件的第二个集合元素序列。

示例：

Var q=from r in Formula1.GetChampions()

    join r2 in RacersWithPosition on

    new

{

FirstName=r.FirstName,

LastName=r.LastName

}

equals

new

{

FirstName=r2.FirstName,

LastName=r2.LastName

}

Into yearResults

Select new

{

FirstName=r.FirstName,

LastName=r.LastName,

Wins=r.Wins,

Results=yearResults

}

 

组连接与内连接区别：两者都是满足条件合并数据源（XXX equals xxx）,内连接是把满足条件的第一个集合的一个元素和第二个集合的一个元素合并，生成新的序列的一个元素；而组连接有into语句，把第二个集合中满足条件的所有元素以序列形式存在第一个集合的一个元素里，最终生成序列

集合操作

Intersect()扩展方法，生成两个集合(序列)的交集。比较是通过默认比较器来实现。

Public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> xxx, IEnumerable<TSource>xxx),即比较两个IEnumerable<TSource>序列，使用TSource的默认比较器。如果想自定义比较方式，则使用另一种重载。

示例：

Fun<String, IEnumerable<Racer>> racersByCar=car=>from r in Formula1.GetChampions()

from c in r.Cars

where c==car

select r;

foreach(var racer in racersByCar(“Ferrari”).Intersect(racersByCar(“McLaren”)))

{}

合并

Zip()扩展方法，.NET4引入。就像拉链一样把两个集合缝合到一起，即第一个集合第一项会和第二个集合第一项合并，以此类推。直到到达较小集合末尾。

示例：

Var racers=

racerNames.Zip(racerNamesAndStarts,(first,second)=>first.Name+”, starts:”+second.Starts);

分页

Skip()扩展方法—跳过xxx项

Take()扩展方法—取前xxx项

LINQ中定义变量

let number=r.Years.Count()

聚合操作符

扩展方法,延迟执行

Count()-返回集合（序列）中的项数

Sum()-返回集合（序列）中的数字之和

Min()-返回集合（序列）中的数字最小值

Max()-返回集合（序列）中的数字最大值

Average()-返回集合（序列）中的平均值

Aggregate()-做累积计算

转换操作符

立即执行查询

ToList()-转成List<T>

ToArray()-转成数组

ToDictionary-转成Dictionary<TKey,TElement> (Key, Element一一对应)

ToLookup()-转成Lookup< TKey,TElement >(一个key对应多个Element)

生成操作符

非扩展方法，只是Enumerable类的普通静态函数

Enumerable.Range(start,count)-返回整数范围内的整数序列(递增)

Enumerable.Repeat<TResult>(TResult element, int count)-生成重复的序列（TResult即要重复的类型）

Enumberable.Empty<TResult>()-返回一个具有指定类型的空的IEnumerable<T>

PLINQ

多个线程同时处理该查询

ParallelEnumerable类的AsParallel()方法扩展了普通的IEnumerable<T>接口，使得普通的IEnumerable<T>对象实现并行查询。