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 = {0,1,2,3,4,5,6,7,8,9};

             var result = from v in values
                          where v > 3 
                          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少年","成都","18","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 = 1; i < 10; i++)
            {
                users.Add(new UserBaseInfo(i, "user0" + i.ToString(), "user0" + i.ToString() + "@web.com"));
            }


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

                         where u.ID < 3
                         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 = 1; i < 10; 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 < 3 && al.ToString().IndexOf("1")>1
                         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 = 1; i < 10; 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<3

                         from ub in usersB

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

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

运行结果如下: