LINQ标准查询操作符（二）——Join、GroupJoin、GroupBy、Concat

LINQ标准查询操作符（二）——Join、GroupJoin、GroupBy、Concat、

联系操作符

联接是指将一个数据源对象与另一个数据源对象进行关联或者联合的操作。这两个数据源对象通过一个共同的值或者属性进行关联。

LINQ有两个联接操作符：Join和GroupJoin。

1、Join

Join操作符类似于T-SQL中的inner join，它将两个数据源相联接，根据两个数据源中相等的值进行匹配。例如，可以将产品表与产品类别表相联接，得到产品名称和与其相对应的类别名称。以下的代码演示了这一点：

[csharp]  view plain copy print ?

1. using (NorthwindDataContext db = new NorthwindDataContext())  
2. {  
3.     db.Log = Console.Out; //将生成的T-SQL语句输出到控制台中   
4.     //查询语法   
5.     var query =  
6.         from p in db.Products  
7.         join c in db.Categories on p.CategoryID equals c.CategoryID  
8.         where p.CategoryID == 1  
9.         select p;  
10.     //方法语法   
11.     var q =  
12.         db.Products  
13.         .Join  
14.         (  
15.             db.Categories,  
16.             p => p.CategoryID,  
17.             c => c.CategoryID,  
18.             (p, c) => p  
19.         )  
20.         .Where(p => p.CategoryID == 1);  
21.     foreach (var item in query)  
22.     {  
23.         Console.WriteLine(item.ProductName);  
24.     }  
25. }  

以上代码为表述清晰加入了一个条件“where p.CategoryID == 1”，即仅返回产品类别ID为1的所有产品。

2、GroupJoin

GroupJoin操作符常应用于返回“主键对象-外键对象集合”形式的查询，例如“产品类别-此类别下的所有产品”。以下的代码演示了这一点：

[csharp]  view plain copy print ?

1. using (NorthwindDataContext db = new NorthwindDataContext())  
2. {  
3.     db.Log = Console.Out; //将生成的T-SQL语句输出到控制台中   
4.     //查询语法   
5.     var query =  
6.         from c in db.Categories  
7.         join p in db.Products on c.CategoryID equals p.CategoryID into r  
8.         select new  
9.         {  
10.             c.CategoryName,  
11.             Products = r  
12.         };  
13.     //方法语法   
14.     var q =  
15.         db.Categories  
16.         .GroupJoin  
17.         (  
18.            db.Products,  
19.            c => c.CategoryID,  
20.            p => p.CategoryID,  
21.            (c, p) => new  
22.            {  
23.                c.CategoryName,  
24.                Products = p  
25.            }  
26.         );  
27.     foreach (var item in query)  
28.     {  
29.         Console.WriteLine("{0} =>", item.CategoryName);  
30.         foreach (var p in item.Products)  
31.         {  
32.             Console.WriteLine(p.ProductName);  
33.         }  
34.         Console.WriteLine("----------------------------------------------");  
35.     }  
36. }  
37. 
    

 分组操作符

分组是根据一个特定的值将序列中的元素进行分组。LINQ只包含一个分组操作符：GroupBy。

下面的示例中使用了产品表，以CategoryID作为分组关键值，按照产品类别对产品进行了分组。

[csharp]  view plain copy print ?

1. using (NorthwindDataContext db = new NorthwindDataContext())  
2. {  
3.     db.Log = Console.Out; //将生成的T-SQL语句输出到控制台中   
4.     //查询语法   
5.     var query =  
6.         from p in db.Products  
7.         group p by p.CategoryID;  
8.     //方法语法   
9.     var q =  
10.         db.Products  
11.         .GroupBy(p => p.CategoryID);  
12.     foreach (var item in query)  
13.     {  
14.         Console.WriteLine("{0} =>", item.Key);  
15.         foreach (var p in item)  
16.         {  
17.             Console.WriteLine(p.ProductName);  
18.         }  
19.         Console.WriteLine("----------------------------------------------");  
20.     }  
21. }  

执行GroupBy得到的序列中包含的元素类型为IGrouping，其Key属性代表了分组时使用的关键值，遍历IGrouping元素可以读取到每一个T类型。在此示例中，对应的元素类型为IGrouping，其Key属性即为类别ID，遍历它可以读取到每一个产品对象。

串联操作符

串联是一个将两个集合联接在一起的过程。在LINQ中，这个过程通过Concat操作符来实现。

在下面的示例中，将会把类别名称串联在产品名称之后：

[csharp]  view plain copy print ?

1. using (NorthwindDataContext db = new NorthwindDataContext())  
2. {  
3.     db.Log = Console.Out; //将生成的T-SQL语句输出到控制台中   
4.     //方法语法   
5.     var q =  
6.         db.Products  
7.         .Select(p => p.ProductName)  
8.         .Concat  
9.        (  
10.             db.Categories.Select(c => c.CategoryName)  
11.         );  
12.     foreach (var item in q)  
13.     {  
14.         Console.WriteLine(item);  
15.     }  
16. }