LINQ之路13：LINQ Operators之连接(Joining)
Joining
IEnumerable<TOuter>, IEnumerable<TInner>→IEnumerable<TResult>
|
Operator |
说明 |
SQL语义 |
|
Join |
应用一种查询策略来匹配两个集合中的元素，产生一个平展的结果集 |
INNER JOIN |
|
GroupJoin |
同上，但是产生一个层次结果集 |
INNER JOIN, LEFT OUTER JOIN |
Join & GroupJoin Arguments
|
参数 |
类型 |
|
外层/Outer sequence |
IEnumerable<TOuter> |
|
内层/Inner sequence |
IEnumerable<TInner> |
|
外键选择器/Outer key selector |
TOuter => TKey |
|
内键选择器/Inner key selector |
TInner => TKey |
|
结果选择器/Result selector |
Join： (TOuter,TInner) => TResult GroupJoin： (TOuter,IEnumerable<TInner>) => TResult |
查询表达式语法
from outer-var in outer-enumerable
join inner-var in inner-enumerable on outer-key-expr equals inner-key-expr
[ into identifier ]
简介
Join和GroupJoin通过匹配两个输入sequence来产生单个输出sequence。Join产生平展结果集，而GroupJoin产生层次结果集。Join和GroupJoin提供了Select和SelectMany的替代策略。
Join和GroupJoin的优点是他们对于本地内存集合的执行更加有效，因为他们开始就把内层sequence装载到一个按键排序的查找器，这样就避免了重复的遍历每一个内层元素。他们的缺点则是他们只提供了inner和left out join的功能，而cross joins和不等连接non-equi joins还是只能通过Select/SelectMany来实现。
对于LINQ to SQL和Entity Framework查询来讲，Join和GroupJoin并没有提供相对于Select和SelectMany的任何真正优化，因为他们只是生成相应的SQL语句，而执行是在数据库引擎中完成的。
下表总结了 每种join策略的差异：
表：连接策略
|
策略 |
结果形状 |
本地查询效率 |
Inner joins |
Left outer joins |
Cross joins |
Nonequi joins |
|
Select + SelectMany |
Flat |
Bad |
Yes |
Yes |
Yes |
Yes
|
|
Select + Select |
Nested |
Bad |
Yes |
Yes |
Yes |
Yes
|
|
Join |
Flat |
Good |
Yes |
- |
- |
- |
|
GroupJoin |
Nested |
Good |
Yes |
Yes |
- |
- |
|
GroupJoin + SelectMany |
Flat |
Good |
Yes |
Yes |
- |
- |
Join
Join运算符执行一个inner join，产生一个平展的输出sequence。示范Join的最简单方式是使用LINQ to SQL，下面的示例列出所有的Customers和他们的Purchases：
IQueryable<string> query =
from c in dataContext.Customers
join p in dataContext.Purchases on c.ID equals p.CustomerID
select c.Name + " bought a " + p.Description;
//Result:
Tom bought a Bike
Tom bought a Holiday
Dick bought a Phone
Harry bought a Car
结果与我们使用SelectMany方式查询时是一致的。
要看到Join相对于SelectMany的优势，我们必须先把查询转为本地查询，如下所示：
//把所有customers和purchases拷贝到数组，以实现本地查询
Customer[] customers = dataContext.Customers.ToArray();
Purchase[] purchases = dataContext.Purchases.ToArray();
var slowQuery = from c in customers
from p in purchases
where c.ID == p.CustomerID
select c.Name + " bought a " + p.Description;
var fastQuery = from c in customers
join p in purchases on c.ID equals p.CustomerID
select c.Name + " bought a " + p.Description;
尽管上面两个查询产生相同的结果，但是使用join的查询快得多，因为它的Enumerable实现把内层collection预先装载到一个按键排序的查找器。
join的查询语法如下：
join inner-var in inner-sequence on outer-key-expr equals inner-key-expr
LINQ中的Join运算符会区分对待outer sequence和inner sequence，语法上看：
- Outer sequence是输入sequence (本例中是customers).
- Inner sequence是我们引入的新集合 (本例中是purchases).
Join执行内连接(inner joins)，意味着没有任何Purchases的Customers会被排除在结果之外。对于inner joins，我们可以交换查询的inner和outer sequences并得到相同的结果：
var fastQuery = from p in purchases
join c in customers on p.CustomerID equals c.ID
select c.Name + " bought a " + p.Description;
我们可以在查询中继续添加join子句。比如，如果每个purchase有一个或多个purchase items，我们可以使用如下查询来join purchase items：
from c in customers
join p in purchases on c.ID equals p.CustomerID // first join
join pi in purchaseItems on p.ID equals pi.PurchaseID // second join
...
purchases是第一个join的inner sequence和第二个join的outer sequence。我们可以通过嵌套的foreach来获得相同的结果(低性能)：
foreach (Customer c in customers)
foreach (Purchase p in purchases)
if (c.ID == p.CustomerID)
foreach (PurchaseItem pi in purchaseItems)
if (p.ID == pi.PurchaseID)
Console.WriteLine(c.Name + "," + p.Price + "," + pi.Detail);
在查询语法中，前一个join引入的变量会保持在作用域之内，就像SelectMany样式查询中的外部范围变量那样，我们还可以在join子句中间插入where和let子句。
对多个键值进行Join
我们可以使用匿名类型来对多个键值进行Join，如下所示：
from x in sequenceX
join y in sequenceY on new { K1 = x.Prop1, K2 = x.Prop2 }
equals new { K1 = y.Prop3, K2 = y.Prop4 }
...
要使上面的查询正确执行，两个匿名类型的结构必须完全一致，这样编译器把他们对应到同一个实现类型，从而使连接键值彼此兼容。
Join的方法语法
下面的join查询语法
from c in customers
join p in purchases on c.ID equals p.CustomerID
select new { c.Name, p.Description, p.Price };
对应的方法语法如下：
customers.Join( // outer collection
purchases, // inner collection
c => c.ID, // outer key selector
p => p.CustomerID, // inner key selector
(c, p) => new { c.Name, p.Description, p.Price } // result selector
);
结果选择器表达式为输出sequence创建每个element。如果我们需要在数据转换之前添加其他子句比如orderby：
from c in customers
join p in purchases on c.ID equals p.CustomerID
orderby p.Price
select c.Name + " bought a " + p.Description;
那么在方法语法中，我们必须在结果选择器中手动构建一个临时的匿名类型，在该匿名类型中保存c和p：
customers.Join( // outer collection
purchases, // inner collection
c => c.ID, // outer key selector
p => p.CustomerID, // inner key selector
(c, p) => new { c, p }) // result selector
.OrderBy(x => x.p.Price)
.Select(x => x.c.Name + " bought a " + x.p.Description);
通常情况下，join的查询表达式语法更加简洁。
GroupJoin
GroupJoin和Join一样执行连接操作，但它不是返回一个平展的结果集，而是一个层次结构的结果集，使用每个外层element进行分组。除了inner joins，GroupJoin还允许outer joins。GroupJoin的查询语法也与Join相似，只是后面紧跟着into关键字。
// Here’s the most basic example of GroupJoin:
IEnumerable<IEnumerable<Purchase>> query =
from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
select custPurchases; // custPurchases is a sequence
直接出现在join子句之后的into关键字会被翻译为GroupJoin，而在select或group子句之后的into表示继续一个查询。虽然他们有一个共同的特征：都引入了一个新的查询变量，但是into关键字的这两种使用方式大不相同，必须引起注意。
其结果是一个包含了多个sequences的sequence，我们可以通过如下方式进行遍历：
foreach (IEnumerable<Purchase> purchaseSequence in query)
foreach (Purchase p in purchaseSequence)
Console.WriteLine(p.Description);
但是这种方式不是非常有用，原因在于outer sequence并没有到outer customer的引用，所以purchaseSequence虽然是按customer进行分组的，但我们在结果中却失去了customer的相关信息。通常情况下，我们会在数据转换中添加对外部范围变量的引用：
from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
select new { CustName = c.Name, custPurchases };
这会得到和下面的Select子查询相同的结果（对于本地查询来说，Select效率不如join）：
from c in customers
select new
{
CustName = c.Name,
custPurchases = purchases.Where(p => c.ID == p.CustomerID)
};
默认情况下，GroupJoin相当于left outer join。要得到inner join（排除没有任何purchases的customers），可以对custPurchases添加过滤条件：
from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
where custPurchases.Any()
select ...
GroupJoin的into关键字之后的子句比如where针对subsequence，而不是单个的child elements。如果要对单独的purchases添加条件，必须在join之前调用Where：
from c in customers
join p in purchases.Where(p2 => p2.Price > 1000)
on c.ID equals p.CustomerID
into custPurchases ...
平展的外连接/Flat outer joins
事情在我们希望得到一个outer join和平展的结果集时会陷入两难的境地。GroupJoin让我们获得outer join；Join给了我们平展的结果集。所以解决方案就是先调用GroupJoin，然后对每个child sequence使用DefaultIfEmpty，最后调用SelectMany来获取平展结果集：
from c in customers
join p in purchases on c.ID equals p.CustomerID into custPurchases
from cp in custPurchases.DefaultIfEmpty()
select new
{
CustName = c.Name,
Price = cp == null ? (decimal?)null : cp.Price
};
如果custPurchases为空，DefaultIfEmpty将产生一个null值。第二个from子句会被翻译成SelectMany。所以，它会平展输出所有的purchase subsequence，将他们合并到单一的输出sequence。
使用lookups
在Enumerable的实现中，Join和GroupJoin的工作分为两个步骤。首先，他们会把内层sequence装载到一个查找器，然后通过该查找器来查询外层sequence。一个查找器(lookup)是一个分组的sequence并可以通过key来直接访问。或者我们可以把它想象成一个dictionary，其中每个元素是一个sequence和对应的key。
查找器是只读的并通过如下接口定义：
public interface ILookup<TKey, TElement> :
IEnumerable<IGrouping<TKey, TElement>>, IEnumerable
{
int Count { get; }
bool Contains(TKey key);
IEnumerable<TElement> this[TKey key] { get; }
}
在处理本地集合时，我们甚至可以手动创建和查询lookups来作为join运算符的替代策略。这么做有如下优点：
- 我们可以在多个查询之间重用同一个查找器（lookup）
- 对lookup进行查询可以让我们更好的理解Join和GroupJoin的工作方式
ToLookup扩展方法创建一个lookup，下面的代码把所有的purchases装载到一个lookup（用CustomerID作为Key）:
ILookup<int?, Purchase> purchLookup =
purchases.ToLookup(p => p.CustomerID, p => p);
第一个参数选择键值，第二个参数选择作为value值被装载到lookup中的对象。读取一个lookup就像读取一个dictionary，不同之处在于索引器返回的是一个包含多个匹配元素的sequence。下面的代码遍历所有CustomerID为1的purchases：
foreach (Purchase p in purchLookup[1])
Console.WriteLine(p.Description);
通过使用lookup，我们可以让SelectMany/Select查询运行得像Join/GroupJoin查询一样高效。Join相当于在lookup上使用SelectMany：
from c in customers
from p in purchLookup[c.ID]
select new { c.Name, p.Description, p.Price };
通过添加DefaultIfEmpty可以让上面的查询变成一个outer join：
from c in customers
from p in purchLookup[c.ID].DefaultIfEmpty()
select new
{
c.Name,
Descript = p == null ? null : p.Description,
Price = p == null ? (decimal?)null : p.Price
};
GroupJoin等价于在数据转换时读取lookup：
from c in customers
select new
{
CustName = c.Name,
CustPurchases = purchLookup[c.ID]
};
Enumerable实现
通过前面的介绍，现在我们可以来看看Join和GroupJoin在LINQ中的实现了。
下面是Enumerable.Join实现的简化版本（没有null checking）：
public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer,
IEnumerable<TInner> inner,
Func<TOuter, TKey> outerKeySelector,
Func<TInner, TKey> innerKeySelector,
Func<TOuter, TInner, TResult> resultSelector)
{
ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector);
return from outerItem in outer
from innerItem in lookup[outerKeySelector(outerItem)]
select resultSelector(outerItem, innerItem);
}
GroupJoin的实现与Join类似：
public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer,
IEnumerable<TInner> inner,
Func<TOuter, TKey> outerKeySelector,
Func<TInner, TKey> innerKeySelector,
Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
{
ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector);
return from outerItem in outer
select resultSelector(outerItem, lookup[outerKeySelector(outerItem)]);
}
