精通LINQ －－4.2.7 join子句

    在LINQ查询表达式中，join子句比较复杂，它可以设置两个数据源之间的关系。当然，这两个数据源之间必须存在相关联的属性或值。join子句可以实现以下3种联接关系。

q      内部联接，元素的联接关系必须同时满足被联接的两个数据源。

q      分组联接，含有into子句的join子句。

q      左外部联接。

1．内部联接

内部联接要求元素的联接关系必须同时满足被联接的两个数据源，和SQL语句中的INNER JOIN子句相似。下面的代码实例中的InnerJoinQuery()函数演示了join子句内部联接users和roles数据源的查询方法，具体步骤说明如下。

（1）创建两个数据源：users和roles。其中，users数据源的数据类型为List<UserInfo>，roles数据源的数据类型为List<RoleInfo>。

（2）使用where子句筛选元素的ID值小于9的元素。

（3）使用join子句内部联接roles数据源，联接关系为“相等”。

（4）使用foreach语句输出查询的结果。

private void InnerJoinQuery()

         {        ///构建数据源

                   List<UserInfo> users = new List<UserInfo>();

                   List<RoleInfo> roles = new List<RoleInfo>();

                   for (int i = 1; i < 10; i++)

                   {

                            users.Add(new UserInfo(i, "User0" + i.ToString(),"User0" + i.ToString() + "@web.com",i * 2));

                            roles.Add(new RoleInfo(i,"RoleName0" + i.ToString()));

                   }                

                   ///查询ID值小于9，且角色包含在roles中的用户

                   var value = from u in users

                                               where u.ID < 9

                                               join r in roles on u.RoleID equals r.ID

                                               select u;

                   ///显示查询结果

                   foreach (var v in value)

                   {

                            Response.Write(v.Username + "</br>");

                   }

         }

运行上述实例代码，在IE浏览器中查看join子句内部联接的结果，如图所示。

2．分组联接

含有into子句的join子句被分组联接。分组联接产生分层数据结构，它将第一个集合中的每个元素与第二个集合中的一组相关元素进行匹配。在查询结果中，第一个集合中的元素都会出现在查询结果中。如果第一个集合中的元素在第二个集合中找到相关元素，则使用被找到的元素，否则使用空。

下面的代码实例中的GroupJoinQuery()函数演示了join子句分组联接users和roles数据源的查询方法，具体步骤说明如下。

（1）创建两个数据源：users和roles。其中，users数据源的数据类型为List<UserInfo>，roles数据源的数据类型为List<RoleInfo>。

（2）使用where子句筛选元素的ID值小于9的元素。

（3）使用join子句分组联接roles数据源，联接关系为“相等”，组的标识符为“g”。

（4）使用select子句查询一个新类型的数据。其中，Roles属性的值为分组g的值，它包含第一个集合的元素（用户）相关角色的列表。

（5）使用foreach语句输出查询的结果。

private void GroupJoinQuery()

         {        ///构建数据源

                   List<UserInfo> users = new List<UserInfo>();

                   List<RoleInfo> roles = new List<RoleInfo>();

                   for (int i = 1; i < 10; i++)

                   {

                            users.Add(new UserInfo(i,"User0" + i.ToString(),"User0" + i.ToString() + "@web.com",i * 2));

                            roles.Add(new RoleInfo(i,"RoleName0" + i.ToString()));

                   }

                   ///查询ID值小于9，且角色包含在roles中的用户

                   var value = from u in users

                                               where u.ID < 9

                                               join r in roles on u.RoleID equals r.ID into g

                                               select new

                                               {

                                                        ID = u.ID,

                                                        Username = u.Username,

                                                        Email = u.Email,

                                                        RoleID = u.RoleID,

                                                        Roles = g.ToList()

                                               };

                   ///显示查询结果

                   foreach (var v in value)

                   {

                            Response.Write(v.Username + ","

+ (v.Roles.Count > 0 ? v.Roles[0].RoleName : string.Empty) + "</br>");

                   }

         }

运行上述实例代码，在IE浏览器中查看join子句分组联接的结果的结果，如图所示。

3．左外部联接

左外部联接与SQL语句中的LEFT JOIN子句比较相似，它将返回第一个集合中的每一个元素，而无论该元素在第二个集合中是否具有相关元素。

注意：LINQ查询表达式若要执行左外部联接，往往与DefaultIfEmpty()方法与分组联接结合起来使用。如果第一个集合中的元素没有找到相关元素时，DefaultIfEmpty()方法可以指定该元素的相关元素的默认元素。

下面的代码实例中的LeftOutJoinQuery()函数演示了join子句左外部联接users和roles数据源的查询方法，具体步骤说明如下。

（1）创建两个数据源：users和roles。其中，users数据源的数据类型为List<UserInfo>，roles数据源的数据类型为List<RoleInfo>。

（2）使用where子句筛选元素的ID值小于9的元素。

（3）使用join子句分组联接roles数据源，联接关系为“相等”，组的标识符为“gr”。

（4）使用frome子句选择gr分组的默认元素。

（5）使用select子句查询一个新类型的数据。其中，Roles属性的值为分组gr的值，它包含第一个集合的元素（用户）相关角色的列表。

（6）使用foreach语句输出查询的结果。

private void LeftOutJoinQuery()

         {        ///构建数据源

                   List<UserInfo> users = new List<UserInfo>();

                   List<RoleInfo> roles = new List<RoleInfo>();

                   for (int i = 1; i < 10; i++)

                   {

                            users.Add(new UserInfo(i,"User0" + i.ToString(),"User0" + i.ToString() + "@web.com",i * 2));

                            roles.Add(new RoleInfo(i,"RoleName0" + i.ToString()));

                   }

                   ///查询ID值小于9，且角色包含在roles中的用户

                   var value = from u in users

                                               where u.ID < 9

                                               join r in roles on u.RoleID equals r.ID into gr

                                               from ur in gr.DefaultIfEmpty()

                                               select new

                                               {

                                                        ID = u.ID,

                                                        Username = u.Username,

                                                        Email = u.Email,

                                                        RoleID = u.RoleID,

                                                        Roles = gr.ToList()

                                               };

                   ///显示查询结果

                   foreach (var v in value)

                   {

                            Response.Write(v.Username + ","

+ (v.Roles.Count > 0 ? v.Roles[0].RoleName : string.Empty) + "</br>");

                   }

         }

运行上述实例代码，在IE浏览器中查看join子句左外部联接的结果，如图所示。