Linq专题之Linq查询from子句

　　Linq查询表达式包含8个常用的子句：from、where、select、join、into、orderby、group、let。我们来看看详细的说明。
      from:      指定查询操作的数据源和范围变量

　　where：    筛选元素的逻辑条件，一般由逻辑运算符("与","或")组成

　　select:    指定查询结果的类型和表现形式

　　orderby:   对查询结果进行排序，可以升序也可以降序

　　group：    对查询结果进行分组

　　into：     提供一个临时标识符，该标识符可以充当对join、group或select子句的结果的引用

　　join：     连接多个查询操作的数据源

　　let：      引入用于存储查询表达式中的子表达式结果的范围变量

　　Linq的查询表达式必须以 from子句开头，并且以select或group子句结束。在第一个from子句和最后一个select或group子句之间，查询表达式可以包含一个或多个where、orderby、group、join、let子句，甚至from子句。

另外，join和group子句还可以使用into子句指定临时标识符号。我们来看看下面的一个简单的查询表达式：

 private void LinqTest()
         {
              int[] values = {,,,,,,,,,};

              var result = from v in values
                           where v >
                           select v;
         }

下面我们就来逐一的讲解一下这8个子句的用法。
1、from子句

　　linq查询表达式必须包含from子句且以from子句开头，如果该查询中包含子查询，那么子查询也必须以from子句开头。from子句指定查询操作的数据源和范围变量，数据源包括本身和子查询的数据源，范围变量表示源序列中的每一个元素。

上面的简单查询例子中，是存数组values中查询出大于3的元素，其中values就是数据源，v就是变量范围，即表示values中的每一个元素。

　　值得注意的是from指定的数据源类型必须为IEnumerable、IEnumerable<T>或者这两者的派生类型。

a、数据源

      在from子句中，如果数据源实现了IEnumerable<T>，那么vs编译器就能够自动推断出范围变量的类型。

 private void LinqTest()
         {
             List<string> values = new List<string> {"IT少年","成都","","boy","pro"};

             var result = from v in values
                          where v == "IT少年"
                          select v;
         }

上面的代码中，范围变量V的类型就是string类型，该查询操作是查询出内容为"IT少年"的字符串。
　　 b、单个的from子句查询

　　在一个Linq查询中只包含一个from子句的查询我们就称为单个的from子句查询。我们来看看单个的from查询：

  private void SingleFromQuery()
         {
             //准备数据源创建一个泛型列表元素类型为UserBaseInfo
             List<UserBaseInfo> users = new List<UserBaseInfo>();

             for (int i = ; i < ; i++)
             {
                 users.Add(new UserBaseInfo(i, "user0" + i.ToString(), "user0" + i.ToString() + "@web.com"));
             }

             //以下是创建Linq查询
             var result = from u in users

                          where u.ID <
                          select u;

             foreach (var u in result)
             {
                 Response.Write("ID:" + u.ID + "</br>" + "username:" + u.UserName + "</br>");
             }
         }

我们查询出id小于3个元素，然后循环输入元素的id和username。我们看看输出结果：

　　c、复合from子句查询

　　在一些复杂的情况下，数据源的元素还包含子数据源。如果我们要查询子数据源中的数据，就需要用复合from子句。下面的ComplexFromQuery方法函数演示了复合from子句查询方法。

(1)创建数据类型为List<UserBaseInfo>的数据源users，其中users元素中AliasName属性的数据类型为List<string>,即该属性的值也是一个子数据源。

UserBaseInfo类如下：

   public class UserBaseInfo
     {
         private List<string> aliasname;
         private int id;
         private string email;
         private int roleid;
         private string username;

         public UserBaseInfo(int Id, string userName, string email, List<string> aliasName)
             : this(Id, userName, email)
         {

             this.aliasname = aliasName;
         }

         public UserBaseInfo(int Id, string userName, string email)
         {
             this.id = Id;
             this.username = userName;
             this.email = email;
         }
  public UserBaseInfo(int Id, string userName, string email, int roleId)
             : this(Id, userName, email)
         {
             this.roleid = roleId;
         }

         public UserBaseInfo(int Id, string userName, string email, int roleId, List<string> aliasName)
             : this(Id, userName, email, roleId)
         {
             this.aliasname = aliasName;
         }

         public List<string> AliasName
         {
             get { return this.aliasname; }
             set { this.aliasname = AliasName; }
         }
  public int ID
         {
             get { return this.id; }
             set
             {
                 this.id = ID;
             }
         }

         public string Email
         {
             get { return this.email; }
             set { this.email = Email; }
         }

         public int RoleId
         {
             get { return this.roleid; }
             set { this.roleid = RoleId; }
         }

         public string UserName
         {
             get { return this.username; }
             set { this.username = UserName; }
         }
     }

(2)、使用复合from子句查询出id小于3且aliasname包含1的用户。第一个from子句查询users数据源，第二个from子句查询users.AliasName数据源。

 private void ComplexFromQuery()
         {
             //准备数据源创建一个泛型列表元素类型为UserBaseInfo
             List<UserBaseInfo> users = new List<UserBaseInfo>();

             for (int i = ; i < ; i++)
             {
                 users.Add(new UserBaseInfo(i, "user0" + i.ToString(), "user0" + i.ToString() + "@web.com",new List<string>{"AliasName0"+i.ToString()}));
             }

             //以下是查询id值小于3的用户且别名包含字符串"1"
             var result = from u in users
                          from al in u.AliasName
                          where u.ID <  && al.ToString().IndexOf("")>
                          select u;

             foreach (var u in result)
             {
                 Response.Write("ID:" + u.ID + "</br>" + "username:" + u.UserName + "</br>");
             }
         }

我们看看查询结果:

d、多个from子句查询

如果Linq中包含两个或两个以上的独立数据源，我们可以使用多个from子句查询所有数据源中的数据。下面看看多个from子句查询的方法：

(1)创建数据类型为List<UserBaseInfo>的数据源usersA，usersB。

(2)第一个from查询出usersA中ID小于3的用户，第二个from查询出usersB中ID大于5的用户。

private void MultFromQuery()
        {

            List<UserBaseInfo> usersA = new List<UserBaseInfo>();
            List<UserBaseInfo> usersB = new List<UserBaseInfo>();

            for (int i = ; i < ; i++)
            {
                usersA.Add(new UserBaseInfo(i, "user0" + i.ToString(), "user0" + i.ToString() + "@web.com", new List<string> { "AliasName0" + i.ToString() }));

                usersB.Add(new UserBaseInfo(i, "user0" + i.ToString(), "user0" + i.ToString() + "@web.com", new List<string> { "AliasName0" + i.ToString() }));
            }
//以下包含连个查询，一个查询ID小于3的用户，一个查询ID大于5的用户
            var result = from ua in usersA
                         where ua.ID<

                         from ub in usersB

                         where ub.ID>
                         select new{ua.ID,ub.UserName};

            foreach (var u in result)
            {
                Response.Write("ID:" + u.ID + "</br>" + "username:" + u.UserName + "</br>");
            }
        }

运行结果如下: