《LINQ技术详解C#》-2.查询表达式翻译为标准查询操作符

（1）透明标识符

有些翻译步骤要使用透明标识符（*）插入枚举变量。
透明标识符只在翻译过程中存在，翻译结束将不再出现。

(2)翻译步骤

①带有into连续语句的Select和Group语句

from...into...                  ->  from i in 
                                    from ...
                                    ...
例如：  
from c in customers                 from g in
group c by c.Country into g     ->  from c in coustomers
select new                          group c by c.Country
{                                    select new   
    Country = g.Key,                 {
    CustCount = g.Count()             Country = g.Key, 
}                                     CustCount = g.Count()
                                     }  

最后的翻译为：

customer.GroupBy(c=> c.Country)
    .Select( g=> new { Country = g.Key, CustCount = g.Count() })

②显示枚举变量类型

2.1.如果查询表达式包含一个from语句，并且这条语句显示指定了一个枚举变量类型

from T e in s                  ->     from e in s.Cast<T>()
例如：

from Customer c in customers   ->     from c in  customers.Cast<Customer>()
select c

最后结果：

customers.Cast<Customer>()

2.2.如果查询表达式包含一个join语句，并且这条语句显示指定一个枚举变量类型

join T e n s                                    join e in s.Cast<T>()
on k1 equals k2                         ->      on k1 equals k2  
例如：

from c in customers                             from c in customers  
join Order o in orders                          join  o in orders.Cast<Order>()
on c.CustomerID equals o.CustomerID     ->      on c.CustomerID equals o.CustomerID
select new {                                    select new {
    c.Name,o.OrderDate,o.Tatal                      c.Name,o.OrderDate,o.Tatal 
}                                               }

最后的结果：

customers
.Join(orders.Cast<Order>(),
    c => c.CustomerID,
    o => o.CustomerID,
    (c,o) => new { c.Name,o.OrderDate,o.Tatal }
)

③Join语句

3.1.如果查询表达式包含一个from语句，后面跟一个join语句，但是在select语句没有使用into连续语句时，

from e1 in s1							from t in s1
join e2 in s2						->	.Join(s2,
on k1 equals k2						 		  e1 => k1,
select f									  e2 => k2,
											(e1,e2) => f)
										select t
例如：
from c in customers								from t in customers
join o in orders								.Join(orders,
on c.CustomerID equals o.CustomerID	->				c=>c.CustomerID,
select new {                                    	o=>o.CustomerID,
    c.Name,o.OrderDate,o.Tatal                      (c,o) => new {
}													c.Name,o.OrderDate,o.Tatal
													}) select t

最后的结果:

cusotmers
.Join(orders,
    c => c.CustomerID,
    o => o.CustomerID,
    (c,o) => new { c.Name,o.OrderDate,o.Tatal })

3.2.如果表达式包含一个from,后面跟一个join语句，并且select语句后面带有into连续语句时，

from e1 in s1						from t in s1
join e2 in s2						.GroupJoin(s2,
on k1 equals k2			->					   e1 => k1,
into i										   e2 => k2,
select f 									   (e1, i) => f)
										select t

例如：

	from c in customers								from t in customers
	join o in  orders								.GroupJoin(oders,
	on c.CustomerID equals o.CustomerID					c => c.CustomerID,
	into co								->			  o => o.CustomerID,
	select new 											(c,co) => new 
	{ c.Name, Sum => co.Sum(o => o.Total) }				{ c.Name,
														Sum => co.Sum(
														o => co.Total) }
														select t

最后的结果:

cusotmers
.GroupJoin(orders,
    c => c.CustomerID,
    o => o.CustomerID,
    (c,co) => new { c.Name, Sum =co.Sum(o = o.Tatal) })

3.3.如果查询表达式包含一个from语句，后面跟一个join语句，并且在select语句之外的其他语句后面没有带into连续语句时，

from e1 in s1						from * in
join e2 in s2						from e1 in s1
on k1 equals k2			->			from e2 in s2
...									on k1 equals k2
									select new { e1, e2 }

　　代码中有一个代码模式与这个翻译步骤中的第一个代码模式匹配。特别地，代码中还有一个查询表达式，该表达式包含一个from语句，后面一个join语句，并且select语句后面没有跟into连续语句。这样，编译器将重复这个翻译步骤。

3.4.如果查询表达式包含一个from 语句，后面一个join，并且在select语句之外的其他语句后带有into连续语句，

from e1 in s1						from * in
join e2 in s2						from e1 in s1
on k1 equals k2			->			from e2 in s2
into i								on k1 equals k2
...									into i
									select new { e1,e2 }

这次代码有一个模式与翻译步骤第二个代码模式匹配。特别地，代码中还有一个表达式，包含一个from语句，后面跟一个join语句，并且select语句后面带有一个into连续语句。这样编译器将重复这个翻译步骤。

④Let和Where语句

4.1 Let语句

from e in s					from * in
let l = v				->  from e1 in s1
							select new { e, l = v}

例如，（t是一个编译器生成的标识符，对于编写的任何代码都是不可见和不可访问的）

from c in  customers							from * in
let cityStateZip = 								from c in customers
	c.City + "," + c.State + " " + c.Zip  ->		select new {
select new { c.Name , cityStateZip } 			 c,
												 cityStateZip = 
												c.City + "," + c.State + " " + c.Zip }
												select new { c.Name , cityStateZip } 

最后的结果：

customers
.Select(c => new { c , cityStateZip = c.City + "," + c.State + " " + c.Zip })
.Select(c => new { t.c.Name, t.cityStateZip })

4.2.查询表达式包含一个from,并紧跟一个where语句，

from e in s				-> 		from e in s
where w							.Where( e => w)

例如：

from c in customers					from c in customers
where c.Country == "USA"		->	.Where(c => c.Country == "USA")
select new { c.Name, c.Country}		select new { c.Name, c.Country }

最后的结果：

customers
.Where(c => c.Country == "USA" )
.Select(c => new { c.Name, c.Country })

⑤多个（From）语句

5.1.如果查询表达式包含两个from语句，后面一个select语句

from e1 in s1			from c in s1
from e2 in s2		->	.SelectMany(e1 => from e2 in s2
select f							select f )
						select c

例如：（t 是编译器临时产生的变量）

from c in customers						from t in customers
from o in c.Orders						.SelectMany(c => from o in c.Orders
select new							->		select new { 
{ c.Name, o.OrderID, o.OrderDate }				c.Name, o.OrderID, o.OrderDate
													})
											select t

最后的结果

customers
.SelectMany(c => c.Orders
				.Select(o => new{ c.Name, o.OrderID, o.OrderDate }))

5.2.如果查询表达式包含两个from语句，后面select之外的其他语句，

	from e1 in s1				from * in
	from e2 in s2				from e1 in s1
	...					->		from e2 in s2
								select new { e1 ,e2 }

例如，

from c in customers							from o in c.Orders
from o in c.Orders							select new { c,o }
orderby o.OrderDate descending		 ->		orderby o.OrderDate descending
select new									select new
	{ c.Name, o.OrderID, o.OrderDate }			{ c.Name, o.OrderID, o.OrderDate }

最后的翻译：

customers
.SelectMany(c => c.Orders.Select(o => new { c,o }))
.OrderByDescending(t => t.o.OrderDate)
.Select(t => new { t.c.Name, t.o.OrderID, t.o,OrderDate })