Lambda表达式详细总结_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
Lambda表达式详细总结
阅读已结束，下载文档到电脑
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，方便使用
还剩16页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢C#学习笔记五: C#3.0Lambda表达式及Linq解析 - 细胞的理想 - 博客园
最早使用到Lambda表达式是因为一个需求:如果一个数组是:int[] s = new int[]{1,3,5,9,14,16,22};例如只想要这个数组中小于15的元素然后重新组装成一个数组或者直接让s返回一个新数组该怎么截取?
最开始的想法就是将这个s遍历一遍然后判断下再来重新组装成新的数组.好麻烦是不是? 于是便百度到了一个叫做Lambda的东西, 所以用了之后效果如下:
1 class Program
static void Main(string[] args)
int[] s = new int []{ 1,3,5,9,14,16,22 };
var result = from n in s where n & 15 select
int[] b = result.ToArray();
for (int i = 0; i & b.L i++)
Console.WriteLine(b[i]);
Console.ReadKey();
打印结果如我们所想: 1, 3, 5, 9, 14.
剩下的就是在真实的项目中接触到的, 在这里只是作为举例, 不做细致讲解:&
1 var splitTexts = cmbValidationText.Split(new string[] { ma },
2 　　　　　　　　　　　　StringSplitOptions.RemoveEmptyEntries);
if (cmbValidation.Items != null && cmbValidation.Items.Count & 0)
foreach (var splitText in splitTexts)
bool valid = cmbValidation.Items.Any(item =& (item != null) && (item.Enabled) &&
8 　　　　　　　　　　　　(string.Equals(splitText, item.Prefix, StringComparison.OrdinalIgnoreCase)));
if (!valid)
invalidText += splitText.ToString() + CommaAndB
isInvalidTextExist = true;
var categoryAndCapabilities = capabilities.Select(item =&
PRResponseCategory category = null;
PRCapability prCapability = provisioningManager.GetPRCapabilityByKey(item.PRCapabilityKey.
22 　　　　　　　　　　　　GetValueOrDefault());
if (prCapability != null)
category = statusMonitorDao.GetResponseCategoryByKey(prCapability.ResponseCategoryKey.
26 　　　　　　　　　　　　GetValueOrDefault());
return new { Category = category, PRCapability = prCapability, Capability = item };
.Where(item =& (item != null && item.Category != null && item.PRCapability != null))
.OrderBy(item =& item.Category.Code)
.ThenBy(item =& item.PRCapability.AllowNumeric.GetValueOrDefault() ? 1 : 0)
.ThenBy(item =& item.PRCapability.CapabilityCode)
.GroupBy(item =& item.PRCapability.ResponseCategoryKey.GetValueOrDefault())
.ToDictionary(grouping =& grouping.Key, grouping =& grouping.ToList());
这里会不会觉得很神奇? 那么下面就开始Lambda及Linq之旅吧.
1,Linq解析Linq是Language Integrated Query的缩写, 即"语言集成查询"的意思. 它主要包含4个组件: Linq to Object, Linq to XML, Linq to DataSet 和Linq to Sql.更多详细内容可以查看一个国外网站: /linq
下面步入正题:
(1),查询表达式
查询表达式是一种使用查询语法表示的表达式，它用于查询和转换来自任意支持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子句：连接多个用于查询操作的数据源。
1.1,select,from, where子句:示例1下面创建一个查询表达式query，该查询表达式查询arr数组中的每一个元素。int[]arr =new int[]{0,1,2,3,4,5,6,7,8,9};
1 class Program
static void Main()
int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var query = from n in arr
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
示例2下面创建一个查询表达式query2.该查询表达式查询arr数组中大于6的元素。
1 class Program
static void Main()
int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
var query = from n in arr
where n &6
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析2变量只是保存查询操作，而不是查询的结果。当查询表达式执行查询操作时，才会计算该查询表达式的结果。以上两个变量的类型都属于集合类型。
示例3下面创建一个查询表达式query。该查询表达式包含两个from子句，他们分别查询两个独立的数据源；arr1数组和arr2数组。最后，使用select子句计算当前元素的和。
1 class Program
static void Main()
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;
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析3包含符合from子句的查询表达式在查询表达式中，有可能查询表达式的数据源中的每一个元素本身也作为该查询表达式的数据源。那么要查询数据源中的每一个元素中的元素，则需要使用符合from子句。符合from子句类似于嵌套的foreach语句。
1.2,let子句let子句用来创建一个新的范围变量，它用于存储子表达式的结果。let子句使用编程者提供的表达式的结果初始化该变量。一旦初始化了该范围变量的值，它就不能用于存储其他的值。
示例下面创建一个查询表达式query。该查询表达式从arr数组中查询为偶数的元素。
1 class Program
static void Main(string[] args)
int[] arr = new int[] {0,1,2,3,4,5,6,7,8,9};
var query = from n in arr
let isEven = (n % 2 == 0 ? true : false)
where isEven
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析"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的元素。
1.3,orderby子句orderby子句可使返回的查询结果按升序或者降序排序。升序由关键字ascending指定，而降序由关键字descending指定。注意：orderby子句默认排序方式为升序。
示例下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n元素对查询结果进行降序排序。
1 class Program
static void Main()
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
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析orderby子句可以包含一个或多个排序表达式，各个排序表达式使用逗号（,）分隔。
1.4, group子句group子句用来将查询结果分组，并返回一对象序列。这些对象包含零个或更多个与改组的key值匹配的项，还可以使用group子句结束查询表达式。注意：每一个分组都不是单个元素，而是一个序列（也属于集合）。
示例下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n%2表达式的值对查询结果进行分组。
1 class Program
static void Main(string[] args)
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;
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析query查询表达式的结果是一个序列（类型为IEnumerable&IGrouping&int,int&&），该序列的元素类型为IGrouping&int,int&.其实，该查询结果中的元素也是一个序列。
1.5, into子句&下面创建一个查询表达式query。该查询表达式从arr数组中查询大于1且小于6的元素，并且按照n%2表达式的值对查询结果进行分组。该查询表达式的具体说明如下所示：where n&1 && n&6：指定筛选大于1且小于6的元素。group n by n%2 into g: 按照n%2表达式的值对查询结果进行分组(0和0一组, 1和1 一组)，并使用into子句创建临时标识符g。该临时标识符临时保存分组结果。from sn in g：从g标识符指定的每一个分组中查询sn元素。select sn：表示查询sn元素。
1 class Program
static void Main()
new int[]{0,1,2,3,4,5,6,7,8,9};
from n in arr
where n&1&& n&6
group n by n%2 into g
from sn in g
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析上述查询表达式的查询结果包括4个元素，依次为2、4、3和5
1.6, 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元素。
1 class Program
static void Main()
int[] arra
new int[] {0,1,2,3,4,5,6,7,8,9};
int[] arrb
new int[]{0,2,4,6,8};
where a &7
join b in arrb on a equals b
foreach (var element in query)
Console.WriteLine(element);
Console.ReadKey();
分析上述查询表达式首先选择小于7的元素，（包括0~6），然后再与arrb数组进行联接，并获取既包含在{0,1,2,3,4,5,6}集合中，又包含在arrb数组中的元素。最终，查询表达式的结果包含4个元素（0、2、4和6）分组联接：join子句的分组联接包含into子句的join子句的链接。它将左数据源与右数据源的元素一次匹配。左数据源的所有元素都出现在查询结果中。若在右数据源中找到匹配项，则使用匹配的数据，否则用空表示。
(2),使用Linq to XML查询XML文件在Linq提出之前, 我们可以使用XPath来查询XML文件, 但是用XPath时必须首先知道XML文件的具体结构, 而使用Linq to XML则不需要知道这些.而且Linq to XML的代码还更加简洁.
1 class Program
//初始化xml数据
private static string xmlString =
"&Persons&" +
"&Person Id = '1'&" +
"&Name&Barry Wang&/Name&" +
"&Age&18&/Age&" +
"&/Person&" +
"&Person Id = '2'&" +
"&Name&Tony Jia&/Name&" +
"&Age&20&/Age&" +
"&/Person&" +
"&Person Id = '3'&" +
"&Name&Anson Shen&/Name&" +
"&Age&19&/Age&" +
"&/Person&" +
"&/Persons&";
static void Main(string[] args)
Console.WriteLine("使用Linq方法来对XML文件查询, 查询结果是: ");
UsingLinqLinqToXmlQuery();
Console.ReadKey();
//使用Linq来对XML文件进行查询
private static void UsingLinqLinqToXmlQuery()
//导入XML文件
XElement xmlDoc = XElement.Parse(xmlString);
//创建查询, 获取姓名为"李四"的元素
var queryResults
from element in xmlDoc.Elements("Person")
where element.Element("Name").Value == "Barry Wang"
//输出查询结果
foreach (var xele in queryResults)
Console.WriteLine("姓名为: " + xele.Element("Name").Value + "Id为: " + xele.Attribute("Id").Value);
Linq to DataSet其实都和Linq to Object 类似, 这里就不在讲解了.更多内容在以下两个链接:
2,Lambda表达式Lambda表达式可以理解为一个匿名方法, 它可以包含表达式和语句, 并且用于创建委托或转换表达式树.在使用Lambda表示式时, 都会使用"=&"运算符(读作goes to), 该运算符的左边是匿名方法的输入参数, 右边则是表达式或语句块.
这里主要列举下Linq和Lambda表达式的一些区别:
LINQ的书写格式如下：&　　　from 临时变量 in 集合对象或数据库对象 　　　where 条件表达式 　　　　[order by条件] 　　　　select 临时变量中被查询的值 　　　[group by 条件]
Lambda表达式的书写格式如下：　　(参数列表) =& 表达式或者语句块
其中：参数个数：可以有多个参数，一个参数，或者无参数。参数类型：可以隐式或者显式定义。表达式或者语句块：这部分就是我们平常写函数的实现部分（函数体）。&1.查询全部
查询Student表的所有记录。
1 select * from student
from s in Students
Students.Select( s =& s)
2 按条件查询全部：
查询Student表中的所有记录的Sname、Ssex和Class列。
1 select sname,ssex,class from student
from s in Students
select new {
Students.Select( s =& new {
SNAME = s.SNAME,SSEX = s.SSEX,CLASS = s.CLASS
3.distinct 去掉重复的
查询教师所有的单位即不重复的Depart列。
1 select distinct depart from teacher
from t in Teachers.Distinct()
select t.DEPART
Teachers.Distinct().Select( t =& t.DEPART)
4.连接查询 between and
查询Score表中成绩在60到80之间的所有记录。
1 select * from score where degree between 60 and 80
from s in Scores
where s.DEGREE &= 60 && s.DEGREE & 80
Scores.Where(
s.DEGREE &= 60 && s.DEGREE & 80
5.在范围内筛选 In
1 select * from score where degree in (85,86,88)
from s in Scores
new decimal[]{85,86,88}
).Contains(s.DEGREE)
Scores.Where( s =& new Decimal[] {85,86,88}.Contains(s.DEGREE))
6.or 条件过滤
查询Student表中"95031"班或性别为"女"的同学记录。
1 select * from student where class ='95031' or ssex= N'女'
from s in Students
where s.CLASS == "95031"
|| s.CLASS == "女"
Students.Where(s =& ( s.CLASS == "95031" || s.CLASS == "女"))
以Class降序查询Student表的所有记录。
1 select * from student order by Class DESC
from s in Students
orderby s.CLASS descending
Students.OrderByDescending(s =& s.CLASS)
8.count（）行数查询
1 select count(*) from student where class = '95031'
from s in Students
where s.CLASS == "95031"
Students.Where( s =& s.CLASS == "95031" )
.Select( s =& s)
9.avg()平均
查询'3-105'号课程的平均分。
1 select avg(degree) from score where cno = '3-105'
from s in Scores
where s.CNO == "3-105"
select s.DEGREE
).Average()
Scores.Where( s =& s.CNO == "3-105")
.Select( s =& s.DEGREE).Average()
10.子查询查询Score表中的最高分的学生学号和课程号。
1 select distinct s.o from student as s,course as c ,score as sc
2 where s.sno=(select sno from score where degree = (select max(degree) from score))
3 o = (select cno from score where degree = (select max(degree) from score))
from s in Students
from c in Courses
from sc in Scores
let maxDegree = (from sss in Scores
select sss.DEGREE
let sno = (from ss in Scores
where ss.DEGREE == maxDegree
select ss.SNO).Single().ToString()
let cno = (from ssss in Scores
where ssss.DEGREE == maxDegree
select O).Single().ToString()
where s.SNO == sno && c.CNO == cno
select new {
).Distinct()
11.分组 过滤
查询Score表中至少有5名学生选修的并以3开头的课程的平均分数。
1 select avg(degree) from score where cno like '3%' group by Cno having count(*)&=5
from s in Scores
where s.CNO.StartsWith("3")
where cc.Count() &= 5
select cc.Average( c =& c.DEGREE)
Scores.Where( s =& s.CNO.StartsWith("3") )
.GroupBy( s =& s.CNO )
.Where( cc =& ( cc.Count() &= 5) )
.Select( cc =& cc.Average( c =& c.DEGREE) )
14 Linq: SqlMethod
15 like也可以这样写:
s.CNO.StartsWith("3") or SqlMethods.O,"%3")
查询Score表中至少有5名学生选修的并以3开头的课程的平均分数。
1 select avg(degree) from score where cno like '3%' group by Cno having count(*)&=5
from s in Scores
where s.CNO.StartsWith("3")
where cc.Count() &= 5
select cc.Average( c =& c.DEGREE)
Scores.Where( s =& s.CNO.StartsWith("3") )
.GroupBy( s =& s.CNO )
.Where( cc =& ( cc.Count() &= 5) )
.Select( cc =& cc.Average( c =& c.DEGREE) )
14 Linq: SqlMethod
15 like也可以这样写:
s.CNO.StartsWith("3") or SqlMethods.O,"%3")
13. 多表查询
1 select sc.ame,sc.degree from course as c,score as sc where c.cno = sc.cno
from c in Courses
join sc in Scores
select new
sc.AME,sc.DEGREE
10 Lambda:
Courses.Join ( Scores, c =& c.CNO,
sc =& sc.CNO,
(c, sc) =& new
SNO = sc.SNO,
CNAME = c.CNAME,
DEGREE = sc.DEGREE
14,关联多条件查询
现在加上两张表的关联多条件查询, 只有Linq和Lambda表达式
如下是一个两张表关联查询的Linq及Lambda表达式的Demo, 仅供大家参考.
1 class Program
static void Main()
DataTable tableA = new DataTable();
tableA.Columns.Add("Name", typeof(string));
tableA.Columns.Add("Age", typeof(int));
tableA.Columns.Add("Score", typeof(int));
DataTable tableB = new DataTable();
tableB.Columns.Add("Name", typeof(string));
tableB.Columns.Add("Age", typeof(int));
tableB.Columns.Add("Score", typeof(int));
tableA.Rows.Add("Barry", 12, 60);
tableA.Rows.Add("Tony", 24, 70);
tableA.Rows.Add("Tom", 22, 80);
tableA.Rows.Add("Brad", 25, 90);
tableB.Rows.Add("Kitty", 12, 65);
tableB.Rows.Add("Tom", 27, 75);
tableB.Rows.Add("Jhon", 22, 85);
tableB.Rows.Add("Brad", 21, 95);
//单表查询
var singleQuery = tableA.AsEnumerable().Where(stu =& stu.Field&int&("Age") & 20);
foreach (var item in singleQuery)
Console.WriteLine("Case 1 query result: Age {0}, Name {1}", item.Field&int&("Age"),
30 　　　　　　　　　　　　　　item.Field&string&("Name").ToString());
//Linq:两张表的关联查询
var doubleQuery = from a in tableA.AsEnumerable()
from b in tableB.AsEnumerable()
where a.Field&string&("Name") == b.Field&string&("Name") &&
a.Field&int&("Age") != b.Field&int&("Age")
orderby a.Field&string&("Name"), a.Field&int&("Score")
select new
Name = a.Field&string&("Name"),
A_Age = a.Field&int&("Age"),
B_Age = b.Field&int&("Age")
foreach (var item in doubleQuery)
Console.WriteLine("Case 2 query result: Name {0}, tableA_Age {1}, tableB_Age {2}",
48 　　　　　　　　　　　　　　 item.Name, item.A_Age, item.B_Age);
//Lambda:两张表的关联查询
var query = tableA.AsEnumerable()
.Join(tableB.AsEnumerable(),
a =& a.Field&string&("Name"),
b =& b.Field&string&("Name"),
(a, b) =& new
.Where(c =& (c.a.Field&int&("Age") != c.b.Field&int&("Age")))
.OrderBy(d =& d.a.Field&string&("Name"))
.ThenBy(e =& e.a.Field&int&("Score"))
.Select(f =& new
Name = f.a.Field&string&("Name"),
A_Age = f.a.Field&int&("Age"),
B_Age = f.b.Field&int&("Age"),
A_Score = f.a.Field&int&("Score"),
B_Score = f.a.Field&int&("Score")
foreach (var item in query)
Console.WriteLine("Case 3 query result: Name {0}, tableA_Age {1}, tableB_Age {2}, tableA_Score {3},
75 　　　　　　　　　　　　　　tableB_Score {4}",item.Name, item.A_Age, item.B_Age, item.A_Score, item.B_Score);
Console.ReadKey();
　　首先可以看出来, Lambda表达式对于这种多表多条件的查询写法的易读性明显没有Linq高, 所以 还是建议用Linq去写. 运行结果如下图:Linq表达式、Lambda表达式你更喜欢哪个？ - 山冈龙 - 博客园
php和js中文化编程的思想让你的梦想自由的飞翔
什么是Linq表达式？什么是Lambda表达式？
由此可见Linq表达式和Lamdba表达式并没有什么可比性。
那与Lamdba表达式相关的整条语句称作什么呢？在微软并没有给出官方的命名，在《深入理解C#》中称为点标记。
查询表达式、点标记你更喜欢哪个？
所以，我们的标题的提问根本就不合适。应该是&Linq查询表达式和点标记你更喜欢哪个？&。如：
//查询表达式
var students1 = from t in db.Students
where t.Name == "张三"
select new { t.Id, t.Name, t.Age };
var students2 = db.Students
.Where(t =& t.Name == "张三")
.Select(t =& new { t.Id, t.Name, t.Age });
为什么选择点标记&
我相信更多的人偏向选择点标记。具体什么原因我也说不清（可能是点标记中的Lamdba更加优雅吧）。对于我个人来说，也是更加喜欢点标记这种方式。
1、所有的查询表达式都可以转成对应的点标记。反之，不是所有的点标记都可以转成查询表达式。
为什么？因为查询表达式在编译后就直接变成了点标记：（以下是上面两个语句对应的编译后的反编译C#代码）
生成了一模一样的代码。（由于是编译后的，好多乱七八糟的代码。我们只看Where和Select关键字就知道，使用的都是点标记。）
2、点标记确实比查询表达式更加优雅
//查询表达式
var students1 = from t in db.Students
where t.Name == "张三"
var students2 = db.Students
.Where(t =& t.Name == "张三");
我为什么一定要&select t&啊，这句没卵用的废话就不能省吗？是的，省了就报错：
必须需要括号包裹起来才能取结果集？你还能更丑一点吗？
//查询表达式
var students1 = (from t in db.Students
where t.Name == "张三"
select t).ToList();
var students2 = db.Students
.Where(t =& t.Name == "张三")
.ToList();
例三：（为什么说："不是所有的点标记都可以转成查询表达式"【此例只适用于IEnumerator】）
此条点标记你能转成查询表达式吗？
var list = new List&string&() { "张三", "张三", "张三", "张三", "李四", "张三", "李四", "张三", "李四" };
var students2 = list
.Where((item, index) =& item == "张三" && index % 2 == 0)
.Select((item, index) =& new { item, index })
.ToList();
查询表达式你能Reverse吗？
var list = new List&string&() { "张三1", "张三2", "张三3", "张三0", "李四9", "张三3", "李四", "张三2", "李四" };
var students2 = list
.Where((item, index) =& item.Contains("张三"))
.Select((item, index) =& new { item, index })
.Reverse()//反序
.ToList();
什么时候使用查询表达式？
通过上面的对比，好像查询表达式一文不值了。no，不是这样的。
比如下面几种情况我们就可以选择使用查询表达式：
例一：（本例适用于Linq to Object 和 没有建主外键的EF查询）
点标记中的Join需要传四个参数表达式，是不是有点晕了。。。
var list1 = new Dictionary&string, string& { { "1", "张三" }, { "2", "李四" }, { "3", "张三" }, { "4", "张三" } };
var list2 = new Dictionary&string, string& { { "1", "张三" }, { "2", "李四" }, { "3", "李四" }, { "4", "张三" } };
//查询表达式
var obj1 = from l1 in list1
join l2 in list2
on l1.Key equals l2.Key
select new { l1, l2 };
var obj = list1.Join(list2, l1 =& l1.Key, l2 =& l2.Key, (l1, l2) =& new { l1, l2 });
点标记需要区分OrderBy、ThenBy有没有觉得麻烦
//查询表达式
var obj1 = from l1 in list1
join l2 in list2
on l1.Key equals l2.Key
orderby l1.Key, l2.Key descending
select new { l1, l2 };
var obj = list1.Join(list2, l1 =& l1.Key, l2 =& l2.Key, (l1, l2) =& new { l1, l2 })
.OrderBy(li =& li.l1.Key)
.ThenByDescending(li =& li.l2.Key)
.Select(t =& new { t.l1, t.l2 });
总觉得查询表达式更多的只是为了照顾那些写惯了sql的程序员。
联接查询（内联、左联、交叉联）
关于联接查询使用查询表达式会更合适一些这个上面已经说了。
接下来我们写内联、左联、交叉联的查询表达式和对应的点标记代码。（目的：可能有些人不会，同时在这里也给自己做个备忘）
其实关于联接查询，如果EF建好了主外键我还是觉得点标记用起来更爽爽的。
本文并不是要改变你的习惯，也不是否定你的观点。仅仅只是表达个人对点标记和查询表达式的些许理解。
关于是使用查询表达式还是点标记，可能起着更大决定性的作用的是团队共同的习惯和规范。
然后还想说说，只要我们对比什么，很可能就会有人跳出了，什么不要比，用好了都一样，什么什么才是最重要的，什么什么的。。。
就像很多人会反感java和C#的对比，其实我个人觉得对比下底层实现、对比下语法简易也不是不可以的，只要我们可以从中学到知识（个人也是不喜欢对比 谁谁谁学什么工资多少多少）。
昨天的自己对比今天的自己，今天的自己对比明天的自己。只要可以进步为什么不要对比呢？
文章首链：
感谢您的阅读。如果文章对您有用，那么请轻轻点个赞，激励本人后续精彩博文。
随笔 - 332}