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>");
            }
        }

運行結果如下: