你能解释一下这个分组的lambda函数？-c#,.net,linq,lambda,grouping-CodeGo.net
你能解释一下这个分组的lambda函数？
我已经LINQ和lambda表达式了一段时间，但我仍然舒服ECT的函数。
所以，当我工作的一个项目最近我需要去根据关闭的属性对象的一个unique的列表，我跑过这段代码。它的工作原理，和我很好，但我想了解我不喜欢只需插入代码并运行距离问题，如果我能帮助它。
不管怎么说代码：
var listDistinct
=list.GroupBy(
i =& i.value1,
(key, group) =& group.First()
).ToList();
在上面的代码示例中 CodeGo.net，你优先次调用GroupBy并传递给它一个lambda表达式告诉它组由酒店value1。代码的第二部分是
据我所知，key被引用value1在(key, group)但我仍然不包我的头周围一切的发生。
本文地址 ：CodeGo.net/557480/
-------------------------------------------------------------------------------------------------------------------------
1. 什么表达
list.GroupBy(
i =& i.value1,
(key, group) =& group.First())
这创建了一个查询，它在被执行时，分析该序列list以产生基团的序列，然后投射组的序列转换成一个新的序列。在这种情况下，突起是采取的优先项出各组。
优先lambda选择“钥匙”后，该基团构成。在这种情况下，列表中的所有项目上都有value1属性被放入一个组中。它们共享组的“钥匙”的价值。
从键控组的序列中的第二lambda项目;它就像你会做了select上组的序列。这个查询的作用是选择来自使得每个所得到的序列具有的不同的值的列表中的一组value1属性。
的是在这里：
如果不清晰 CodeGo.net，我很高兴通过沿批评的管理。
这group作为正式的lambda的。不group一个保留关键字？
不，group是一个上下文关键字。 LINQ加入到C＃3.0，所以有可能已存在group作为标识符。这些程序时，如果将被打破group被做了保留关键字。相反，group是一个关键字，只有在查询表达式的上下文。查询表达式的外面是一个普通的标识符。
如果你想，如果你想标识符呼吁人们关注这一事实，即它是一个普通的标识符，或group在查询表达式中，你可以告诉通过其前面加“将此视为一个标识符，而不是关键字”@。被我上面写着我要说的代码
list.GroupBy(
i =& i.value1,
(key, @group) =& @group.First())
要分清楚。
有没有在C＃中的其他上下文关键字？
是。我已经他们都在这里：
我想简化这个到列表int怎么办鲜明在此列表中GroupBy：
var list = new[] {1, 2, 3, 1, 2, 2, 3};
如果你调用GroupBy同x =& x，你会得到3组类型：
IEnumerable&IEnumerable&int&&
{{1,1},{2,2,2},{3,3}}
各组的关键是：1，2，3。然后，当调用group.First()，你会得到各组优先项：
{1,1}: -& 1.
{2,2,2}: -& 2
{3,3} -& 3
所以最后的结果是：{1, 2, 3}你的情况与此类似。
这个过载Enumerable.GroupBy方法：
public static IEnumerable&TResult& GroupBy&TSource, TKey, TResult&(
this IEnumerable&TSource& source,
Func&TSource, TKey& keySelector,
Func&TKey, IEnumerable&TSource&, TResult& resultSelector
其中，因为MSDN上说：
组根据指定的键选择器函数对序列，并从每个组的结果值及其关键。
因此，不同于返回一串组（其他重载即IEnumerable&IGrouping&TK, TS&&），此重载让你将每组的单个实例TResult您所选择的。
需要注意的是，你可以得到的基本GroupBy过载和Select：
var listDistinct = list
.GroupBy(i =& i.value1)
.Select(g =& g.First())
.ToList();
(key, group) =& group.First()
这只是服用First()内的每个群组。
内的lambda表达式key是一个关键，要创建一个组（value1在你的例子），并group是IEnumerable&T&一切都有了key。
下面的自我描述的例子将帮助你理解分组：
class Item
public int Value { }
public string Text { }
static class Program
static void Main()
// Create some items
var item1 = new Item {Value = 0, Text = "a"};
var item2 = new Item {Value = 0, Text = "b"};
var item3 = new Item {Value = 1, Text = "c"};
var item4 = new Item {Value = 1, Text = "d"};
var item5 = new Item {Value = 2, Text = "e"};
// Add items to the list
var itemList = new List&Item&(new[] {item1, item2, item3, item4, item5});
// Split items into groups by their Value
// Result contains three groups.
// Each group has a distinct groupedItems.Key --& {0, 1, 2}
// Each key contains a collection of remaining elements: {0 --& a, b} {1 --& c, d} {2 --& e}
var groupedItemsByValue = from item in itemList
group item by item.Value
into groupedItems
select groupedI
// Take first element from each group: {0 --& a} {1 --& c} {2 --& e}
var firstTextsOfEachGroup = from groupedItems in groupedItemsByValue
select groupedItems.First();
// The final result
var distinctTexts = firstTextsOfEachGroup.ToList(); // Contains items where Text is: a, c, e
它equvilant到
var listDistinct=(
from i in list
group i by i.value1 into g
select g.First()
).ToList();
该部分i =& i.value1在你原来的代码是关键选择。在这段代码中，简直就是i.value在组由键的语法。
该部分(key, group) =& group.First()在原来的代码是结果选择的委托。在这段代码中，它从一个更加语义语法写的...选择。就在这里g是group在原代码。
本文标题 ：你能解释一下这个分组的lambda函数？
本文地址 ：CodeGo.net/557480/
Copyright (C) 2017 CodeGo.netlinq/EF/lambda Group by/Order by 多个字段详细用法 - IT大师
& 02:07:06
1）单个字段Group by：//a.Key类型与a.Province字段类型一样
.GroupBy(a&=&&a.Province).Select(a&=&&a.Key).ToList();2）多个字段Group by：//此时返回的数据列表需要自己转换
.GroupBy(a&=&&new&{&a.Date,&a.Week&}).Select(a&=&&a.Key).ToList();3）单个字段Order by：.OrderBy(a&=&&a.Date).ToList()4）多个字段Order by：.OrderBy(a&=&&a.Date).ThenBy(a&=&&a.EndTime).ThenBy(a&=&&a.StartTime).ToList()5）多个字段Order by倒序：.OrderByDescending(a&=&&a.Date).ThenByDescending(a&=&&a.EndTime).ThenByDescending(a&=&&a.StartTime).ToList()
文章链接：
原创说明：转载原创文章时请保留原文链接，谢谢！
转载说明：本站转载文章均标明文章来源，若本篇转载侵犯了您的权益，请联系站长删除！
交流Ｑ群：
开源组件：、7331人阅读
using System.Collections.G
using System.T
using System.T
using System.L
namespace Leaf
public class Test5
public static void Main(string[] args)
List&DbInfo& list = new List&DbInfo&()
new DbInfo(){ DbId=1,HostId=1 },
new DbInfo(){ DbId=2,HostId=1 },
new DbInfo(){ DbId=3,HostId=2 },
new DbInfo(){ DbId=4,HostId=2 }
//如何将list中的对象，group by HostId, 每个HostId保留一条记录? (不要用循环)
//如上面的list, 最终结果会保留 DbId = 1 和 3
List&DbInfo& selected = list.GroupBy(v =& v.HostId).Select(it =& it.First()).ToList();
foreach (DbInfo info in selected)
Console.WriteLine(&DbId:&+info.DbId+&, HostId:&+info.HostId);
Console.ReadLine();
public class DbInfo
public long DbId { }
public long HostId { }
var selected1 = from dbinfo in list
group dbinfo by dbinfo.HostId into list2
select new
list2.First().DbId,
list2.First().HostId
var selected1 = from dbinfo in list
group dbinfo by dbinfo.HostId into list2
select list2.First();
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1627423次
积分：22518
积分：22518
排名：第279名
原创：654篇
转载：278篇
评论：154条
(11)(4)(18)(12)(8)(6)(8)(8)(8)(7)(6)(4)(8)(14)(13)(13)(3)(12)(7)(11)(1)(3)(3)(3)(2)(3)(1)(1)(1)(8)(6)(5)(15)(7)(3)(4)(8)(4)(4)(13)(18)(6)(7)(16)(19)(26)(21)(13)(13)(11)(21)(9)(4)(9)(17)(12)(9)(4)(6)(11)(14)(15)(10)(9)(12)(31)(21)(30)(10)(18)(36)(21)(10)(30)(32)(19)(3)(1)(5)(13)(31)(11)(8)(11)Lambda、Linq 多列分组问题 - 12 - ITeye技术网站
Lambda、Linq 多列分组问题，是非常常见的需求。下面引用论坛某位坛友提出的问题：
课程老师A高一班英语小王B高二班英语小王C高一班英语小张
班级课程老师A高一班英语小王C高一班英语小张
经过分析可以看出，根据课程和老师进行分组，重复的取第一行的数据。传统的方法可能要写很多代码，而用Lambda或者Linq只需要几行代码就能实现。
完整代码如下：
namespace ConsoleApplication1
class Program
static void Main(string[] args)
Data[] data = new Data[]
new Data(){班级="高一班", 课程="英语", 老师="小王"},
new Data(){班级="高二班", 课程="英语", 老师="小王"},
new Data(){班级="高一班", 课程="英语", 老师="小张"},
new Data(){班级="高一班", 课程="英语", 老师="小张"},
//方式1：Lambda
var resultLambda = data.GroupBy(x =& new { 课程 = x.课程, 老师 = x.老师 }).Select(x =& x.FirstOrDefault());
resultLambda.ToList().ForEach(x =& Console.WriteLine(string.Join(",", x.班级, x.课程, x.老师)));
//方式2：Linq
var resultLinq = from p in data
group p by new { p.课程, p.老师 } into g
select new
班级 = g.FirstOrDefault().班级,
课程 = g.Key.课程,
老师 = g.Key.老师,
resultLinq.ToList().ForEach(x =& Console.WriteLine(string.Join(",", x.班级, x.课程, x.老师)));
public class Data
public string 班级 { }
public string 课程 { }
public string 老师 { }
运行结果：
浏览: 852000 次60256人阅读
（一）输入参数
在Lambda表达式中，输入参数是Lambda运算符的左边部分。它包含参数的数量可以为0、1或者多个。只有当输入参数为1时，Lambda表达式左边的一对小括弧才可以省略。输入参数的数量大于或者等于2时，Lambda表达式左边的一对小括弧中的多个参数质检使用逗号（,）分割。
下面创建一个Lambda表达式，它的输入参数的数量为0.该表达式将显示“This is a Lambda expression”字符串。
()=&Console.WriteLine(&This is a Lambda expression.&);
由于上述Lambda表达式的输入参数的数量为0，因此，该Lambda表达式的左边部分的一对小括弧不能被省略。
下面创建一个Lambda表达式，它的输入参数包含一个参数：m。该表达式将计算m参数与2的乘积。
上述Lambda表达式的输入参数省略了一对小括弧，它与“(m)=&m*2”Lambda表达式是等效的。
下面创建一个Lambda表达式，它的输入参数包含两个参数：m和n。该表达式将计算m和n参数的乘积。
(m,n)=&m*n;
（二）表达式或语句块
多个Lambda表达式可以构成Lambda语句块。语句块可以放到运算符的右边，作为Lambda的主体。根据主题不同，Lambda表达式可以分为表达式Lambda和语句Lambda。语句块中可以包含多条语句，并且可以包含循环、方法调用和if语句等。
下面创建一个Lambda表达式，它的右边部分是一个表达式。该表达式计算m参数的平方值。
如果Lambda表达式的右边部分是一个语句块，那么该语句块必须被&{&和&}&包围。
下面创建一个Lambda表达式，它的输入参数包括两个参数：m和n。该表达式的右边包含2个表达式；第一个表达式计算m和n参数的乘积，结果保存为result变量；第二个表达式显示result变量的值。
(m,n)=&{int result=m*n; Console.WriteLine(result);}
上述Lambda表达式的右边部分包含2个表达式，因此，该表达式的右边部分必须被&{&和&}&包围。
（三）查询表达式
查询表达式是一种使用查询语法表示的表达式，它用于查询和转换来自任意支持LINQ的数据源中的数据。查询表达式使用许多常见的C#语言构造，易读简洁，容易掌握。它由一组类似于SQL或XQuery的声明性语法编写的子句组成。每一个子句可以包含一个或多个C#表达式。这些C#表达式本身也可能是查询表达式或包含查询表达式。
●查询表达式必须以from子句开头，以select或group子句结束。第一个from子句和最后一个select子句或group子句之间，可以包含一个活多个where子句、let子句、join子 & 句、orderby子句和group子句，甚至还可以是from子句。它包括8个基本子句，具体说明如下所示。
●from子句：指定查询操作的数据源和范围变量。
●select子句：指定查询结果的类型和表现形式。
●where子句：指定筛选元素的逻辑条件。
●let子句：引入用来临时保存查询表达式中的字表达式结果的范围变量。
●orderby子句：对查询结果进行排序操作，包括升序和降序。
●group子句：对查询结果进行分组。
●into子句：提供一个临时标识符。join子句、group子句或select子句可以通过该标识符引用查询操作中的中坚结果。
●join子句：连接多个用于查询操作的数据源。
下面创建一个查询表达式query，该查询表达式查询arr数组中的每一个元素。
int[]arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query1=from n in arr
下面创建一个查询表达式query2.该查询表达式查询arr数组中大于6的元素。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query2=from n in arr
where n &6
变量只是保存查询操作，而不是查询的结果。当查询表达式执行查询操作时，才会计算该查询表达式的结果。以上两个变量的类型都属于集合类型。
（四）from子句
from子句用来指定查询表达式的数据源和范围变量。它是查询表达式的必有部分，并且它出现在最开始。数据源不但可以包括查询本身的数据源，而且还可以包括子查询的数据源。范围变量用来表示数据源序列中的每一个元素。
注意：from子句指定的数据源的类型必须为IEnumerable，IEnumerable&T&或一种派生类型。
下面创建一个查询表达式query。该查询表达式查询arr数组中的每一个元素。在query查询表达式中，arr数组为数据源，n为范围变量。n范围变量的类型arr数据源的元素类型。
int[] arr =new int[] {0,1,2,3,4,5,67,8,9};
var query =from n in arr
下面我们来学习数据源和包含不同的from子句查询表达式。
数据源：指定数据的来源，它的形式可以为静态数组、动态数组（Arraylist）、集合、数据集（DataSet）、数据表、MML片段、MML文件等。
如果数据源实现了IEnumerable&T&接口，那么编译器可以推断范围变量的类型为其元素类型。例如：数据源的类型为IEnumerable&UserInfo&,那么可以推断出范围 变量的类型为UseInfo。
下面创建一个查询表达式query。该查询表达式查询list反省数组中的每一个元素。在query查询表达式中，list反省数组为数据源。u为范围变量。u范围变量的类型为list数据源的元素类型（UserInfo）。
List&UserInfo& list=...
var query =from u in list
如果当数据源是非泛型IEnumerable类型（如ArrayList等）时，需要显示指定范围变量的类型。
下面创建一个查询表达式query。该查询表达式查询list数组中的每一个元素。在query查询表达式中，list数组为数据源，u为范围变量。u范围变量的类型被指定为list数据源的元素类型（UserInfo）。
ArrayList list =new ArrayList();
list.Add(...);
var query =from UserInfo u in list
包含单个from子句的查询表达式
在查询表达式中，from子句至少有一个。当from子句只有一个时，构成的查询表达式被称为包含单个from子句的查询表达式。一般的，包含单个from子句的查询表达式只包含一个数据源。
下面创建一个查询表达式query。该查询表达式查询arr数组中的每一个元素，它就是一个包含单个from子句的查询表达式。
int[] arr =new int[]{0,1,12,3,4,5,6,7,8,9};
var query =from n in arr
包含多个from子句的查询表达式
在查询表达式中，当from子句有两个或两个以上时，构成的查询表达式被称为包含多个from子句的查询表达式。
下面创建一个查询表达式query。该查询表达式包含两个from子句，他们分别查询两个独立的数据源；arr1数组和arr2数组。最后，使用select子句计算当前元素的和。
int[] arr1= new int[] {0,1,2,3,4,5,6,7,8,9};
int[] arr2=new int[] {0,1,2,3,4,5,6,7,8,9};
var query =from a in arr1
from b in arr2
select a +b;
包含符合from子句的查询表达式
在查询表达式中，有可能查询表达式的数据源中的每一个元素本身也作为该查询表达式的数据源。那么要查询数据源中的每一个元素中的元素，则需要使用符合from子句。符合from子句类似于嵌套的foreach语句。
下面创建一个名称为Test的类，该类包含两个字段：Name和AliasName。其中，Name字段的类型为string，AliasName字段的类型为string类型列表。因此，它也可以作为子查询表达式的数据源。
public class Test
Public string N
Public List&string& AliasN
下面创建一个查询表达式query。该查询表达式包含了一个符合from子句：第一个from子句查询list泛型集合；第二个from子句查询list集合中元素的AliasName字段，为第一个from子句的子查询。最后，使用select子句将u变量的Name属性的值和name变量的值拼接为一个字符串。
List&MUserInfo& list =...
var query =from u in list
from name in u.AliasName
select u.Name+
（五）select子句
select子句用来指定将在执行查询时产生的值的类型。查询表达式必须以select子句或group子句结束。
下面创建一个查询表达式query。该查询表达式查询arr数组中的每一个元素。
int[] arr =new int[] {0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
下面创建一个查询表达式query。该查询表达式查询arr数组中的每一个元素和10的乘积。
int[] arr =new int[] {0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
select n*10;
select子句中的“n*10”表达式决定了查询结果的表现形式，即计算每一个元素和10的乘积。
下面创建一个查询表达式query。该查询表达式查询arr数组中的每一个元素，查询结果是一个对象的集合对象包含两个属性：ID和Name，它在select子句中由匿名对象初始化器创建。每一个对象的ID属性的值是当前元素的值、Name属性的值为元素的值的字符串的表现形式。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
select new
Name =n.ToString()
（六）where子句
where子句用来指导将在查询表达式中返回数据源中的哪些元素。它将一个布尔条件应用于数据源中的每个元素，并返回指定条件的元素。查询表达式可以包含一个或多个where子句。
下面创建一个查询表达式query。该查询表达式从arr数组中查询小于3的元素
int[] arr =new int[] {0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
where n &3
上述where子句只包含一个布尔表达式“n&3”，该表达式将筛选小于3的元素。
在一个where子句中，也可以包含多个布尔表达式，各个表达式直接使用逻辑运算符（如&&和||）分隔。
下面创建一个查询表达式query。该查询表达式从arr数组中查询大于3且小于6的元素。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
where n &3 && n&6
上述where子句包含两个布尔表达式&n&3&和&n&6&,它们共同指定将筛选大于3且小于6的元素。这两个布尔表达式使用&&运算符链接，即计算这两个布尔表达式的逻辑与。
where子句不但可以包含布尔表达式，而且还可以包含返回布尔值的方法。
下面创建一个查询表达式query.该查询表达式从arr数组中查询为偶数的元素。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
private bool IsEven(int i)
return i%2==0?true:
var query =from n in arr
wehre IsEven(n)
上述where子句包含一个返回布尔值的方法&IsEven(int i)&。该方法判定元素是否为偶数。如果是，则返回true，否则返回false。
（七）let子句
let子句用来创建一个新的范围变量，它用于存储子表达式的结果。let子句使用编程者提供的表达式的结果初始化该变量。一旦初始化了该范围变量的值，它就不能用于存储其他的值。
下面创建一个查询表达式query。该查询表达式从arr数组中查询为偶数的元素。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
let isEven =return n%2==0?true:
where isEven
&return n%2==0?true:false&表达式判断n元素是否为偶数。如果是，则返回true，否则返回false。“let isEven =return n%2==0?true:false”表达式使用let子句创建新的范围变量isEven，用来保存&return n%2==0?true:false&表达式的结果。&where
isEven&表达式使用where子句筛选isEven的值为true的元素。
（八）orderby子句
orderby子句可使返回的查询结果按升序或者降序排序。升序由关键字ascending指定，而降序由关键字descending指定。
注意：orderby子句默认排序方式为升序。
下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n元素对查询结果进行降序排序。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
where n&1 && n&6
orderby n descending
orderby子句可以包含一个或多个排序表达式，各个排序表达式使用逗号（,）分隔。
下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素。它使用orderby子句对查询结果进行排序，且包含两个排序关键字，具体说明如下所示：n%2：按照升序排序；n：按照降序排序。
注意：n%2排序关键字优先级大于n排序关键字。因此，该查询表达式的结果首先按照n%2排序关键字升序排序，然后在按照n排序关键字降序排序。
在&orderby n%2 ascending,n descending&表达式中，第一个排序关键字后的&ascending&可以省略。因为默认排序方式为升序。
（九）group子句
group子句用来将查询结果分组，并返回一对象序列。这些对象包含零个或更多个与改组的key值匹配的项，还可以使用group子句结束查询表达式。
注意：每一个分组都不是单个元素，而是一个序列（也属于集合）。
下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n%2表达式的值对查询结果进行分组。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
where n&1 && n&6
group n by n%2;
query查询表达式的结果是一个序列（类型为IEnumerable&IGrouping&int,int&&），该序列的元素类型为IGrouping&int,int&.其实，该查询结果中的元素也是一个序列。
下面使用两个foreach语句显示query查询表达式结果中每一个元素的值。
foreach(var g in query)
foreach(var o in g)
Console.WriteLine(0);
使用group子句对查询结果分组后，每一个分组都存在一个键（由key属性表示）。通过key属性可以获取每一个分组的键的值。
（十）into子句&
into子句可以用来创建一个临时标识符，将group、join或select子句的结果存储到这个标识符中。
下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n%2表达式的值对查询结果进行分组。该查询表达式的具体说明如下所示：
where n&1 && n&6：指定筛选大于1且小于6的元素。
group n by n%2 into g: 按照n%2表达式的值对查询结果进行分组，并使用into子句创建临时标识符g。该临时标识符临时保存分组结果。
from sn in g：从g标识符指定的每一个分组中查询sn元素。
select sn：表示查询sn元素。
int[] arr =new int[]{0,1,2,3,4,5,6,7,8,9};
var query =from n in arr
where n&1&& n&6
group n by n%2 into g
from sn in g
上述查询表达式的查询结果包括4个元素，依次为2、4、3和5
（十一）join子句
join子句用来连接两个数据源，即设置两个数据源之间的关系。join子句支持以下3种常见联接方式。
内部联接：元素的链接关系 必须同时满足两个数据源，类似于SQL语句中的inner join子句。
分组联接：包含into子句的join子句。
左外部联接：元素的链接关系必须满足联接中的左数据源，类似于SQL语句中的left join子句。
内部联接：join子句的内部联接要求两个数据源都必须存在相同的值，即两个数据源都必须存在满足联接关系的元素。
下面创建一个查询表达式query。该查询表达式使用join子句联接了arra和arrb数组，具体说明如下。
创建arra数组，它包含10个元素（0~9）。
创建arrb数组，它包含5个元素（0、2、4、6和8）。
创建query查询。
from a in arra：从arra数组中选择元素，并表示为a。
where a &7: 从arra数组中选择小于7的元素
join b in arrb on a equals b: 将arra和arrb数组进行联接，同时满足a和b相等的条件。其中，b元素是arrb数组中的元素。
select a： 选择a元素。
int[] arra =new int[] {0,1,2,3,4,5,6,7,8,9};
int[] arrb =new int[]{0,2,4,6,8};
var query =from a
where a &7
join b in arrb on a equals b
上述查询表达式首先选择小于7的元素，（包括0~6），然后再喝arrb数组进行联接，并获取既包含在{0,1,2,3,4,5,6}集合中，又包含在arrb数组中的元素。最终，查询表达式的结果包含4个元素（0、2、4和6）
分组联接：join子句的分组联接包含into子句的join子句的链接。它将左数据源与右数据源的元素一次匹配。左数据源的所有元素都出现在查询结果中。若在右数据源中找到匹配项，则使用匹配的数据，否则用空表示。
下面创建一个查询表达式query。该查询表达式使用join子句联接arra和arrb数组，具体说明如下：
创建arra数组，它包含10个元素（0~9）。
创建arrb数组，它包含5个元素（0、2、4、6和8）。
创建query查询。
from a in arra：从arra数组汇总选择元素，并表示为a。
where a&7：从arra数组中选择小于7的元素。
join b in arrb on a equals b into g:将arra和arrb数组进行联接，同时满足a和b相等的条件。最后，保存为g分组。其中，b元素是arrb数组中的元素。
select new{ID=a,Values =g};指定查询结果是一个对象集合。该对象包含两个属性：ID和Values,它在select子句中由匿名对象初始化器创建。每一个对象的ID属性的值是当前元素的值、value属性的值为g分组。
左外部链接： join子句的左外部链接将返回左侧数据源序列中的所有元素，就算它们在右侧序列中没有匹配的元素也是这样。
下面创建一个查询表达式query。该查询表达式使用join子句联接arra和arrb数组，具体说明如下所示：
创建arra数组，它包含10个元素（0~9）。
创建arrb数组，它包含5个元素（0、2、4、6和8）。
创建query查询。
from a in arra：从arra数组中选择元素，并表示为a。
where a &7：从arra数组中选择小于7的元素。
join b in arrb on a equals b into g:将arra和arrb数组进行联接，同时满足a和b相等的条件。最后，保存为g分组。其中，b元素是arrb数组中的元素。
注意：在此，左数据源为&from a in arrb&和&where a &7&产生的数据源，右数据源为arrb数组。
from ab in g.DefaultEmpty():查询g分组中的每一个元素。如果该分组不存在元素，则返回默认值。
如果序列（在此为g）为空，则DefaultEmpty() 方法返回只包含一个元素的序列，该元素类型的值为默认值（在此为0）。
select ab:选择ab元素。
上述查询表达式首先选择小于7的元素（包括0~6），然后再和arrb数组进行左链接。该查询表达式的结果包含7个元素（与左数据源中的元素的数量相等）。如果g分组为空，则返回该分组的元素类型的默认值（0），否则返回该元素。当左数据源中的元素的值为1、3和5时，g分组为空，此时，它将返回默认值0.当左数据源中的元素的值为0、2、4和6时，g分组不为空。此时，它将返回该元素的值，分别为0、2、4和6.最终，查询表达式的结果包含7个元素（0、0、2、0、4、0和6）。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：557165次
积分：6167
积分：6167
排名：第3711名
原创：109篇
评论：883条
(1)(2)(6)(2)(1)(3)(7)(5)(1)(1)(2)(4)(2)(4)(4)(5)(5)(2)(4)(4)(4)(3)(4)(4)(3)(9)(4)(11)(3)(3)(3)}