[讀書筆記]C#學習筆記六: C#3.0Lambda表達式及Linq解析

前言

最早使用到Lambda表達式是因為一個需求:
如果一個數組是:int[] s = new int[]{1,3,5,9,14,16,22};
例如只想要這個數組中小於15的元素然后重新組裝成一個數組或者直接讓s返回一個新數組該怎么截取?

最開始的想法就是將這個s遍歷一遍然后判斷下再來重新組裝成新的數組.好麻煩是不是? 於是便百度到了一個叫做Lambda的東西, 所以用了之后效果如下:

class Program  2 {  3 static void Main(string[] args)  4  {  5 int[] s = new int []{ 1,3,5,9,14,16,22 };  6 var result = from n in s where n < 15 select n;  7 int[] b = result.ToArray();  8 for (int i = 0; i < b.Length; i++)  9  { 10  Console.WriteLine(b[i]); 11  } 12  Console.ReadKey(); 13  } 14 }

打印結果如我們所想: 1, 3, 5, 9, 14.

剩下的就是在真實的項目中接觸到的, 在這里只是作為舉例, 不做細致講解: 

var splitTexts = cmbValidationText.Split(new string[] { IncidentConstant.Comma }, 
　　　　　　　　　　　　StringSplitOptions.RemoveEmptyEntries);  2     if (cmbValidation.Items != null && cmbValidation.Items.Count > 0)  3  {  4         foreach (var splitText in splitTexts)  5  {  6             bool valid = cmbValidation.Items.Any(item => (item != null) && (item.Enabled) && 
　　　　　　　　　　　　(string.Equals(splitText, item.Prefix, StringComparison.OrdinalIgnoreCase)));  7 
            if (!valid)  9  { 10                 invalidText += splitText.ToString() + CommaAndBlank; 11                 isInvalidTextExist = true; 12  } 13  } 14  } 15 
    var categoryAndCapabilities = capabilities.Select(item =>
 { 18         PRResponseCategory category = null; 19         PRCapability prCapability = provisioningManager.GetPRCapabilityByKey(item.PRCapabilityKey.
　　　　　　　　　　　　GetValueOrDefault()); 20         if (prCapability != null) 21  { 22             category = statusMonitorDao.GetResponseCategoryByKey(prCapability.ResponseCategoryKey.
　　　　　　　　　　　　GetValueOrDefault()); 23  } 24         return new { Category = category, PRCapability = prCapability, Capability = item }; 25  }) 26     .Where(item => (item != null && item.Category != null && item.PRCapability != null)) 27     .OrderBy(item => item.Category.Code) 28     .ThenBy(item => item.PRCapability.AllowNumeric.GetValueOrDefault() ? 1 : 0) 29     .ThenBy(item => item.PRCapability.CapabilityCode) 30     .GroupBy(item => item.PRCapability.ResponseCategoryKey.GetValueOrDefault()) 31     .ToDictionary(grouping => grouping.Key, grouping => grouping.ToList());

這里會不會覺得很神奇? 那么下面就開始Lambda及Linq之旅吧.

1,Linq解析
Linq是Language Integrated Query的縮寫, 即"語言集成查詢"的意思. 它主要包含4個組件: Linq to Object, Linq to XML, Linq to DataSet 和Linq to Sql.
更多詳細內容可以查看一個國外網站: http://www.dotnetperls.com/linq

下面步入正題:

(1),查詢表達式

查詢表達式是一種使用查詢語法表示的表達式，它用於查詢和轉換來自任意支持LINQ的數據源中的數據。查詢表達式使用許多常見的C#語言構造，易讀簡潔，容易掌握。它由一組類似於SQL或XQuery的聲明性語法編寫的子句組成。每一個子句可以包含一個或多個C#表達式。這些C#表達式本身也可能是查詢表達式或包含查詢表達式。

查詢表達式必須以from子句開頭，以select或group子句結束。第一個from子句和最后一個select子句或group子句之間，可以包含一個活多個where子句、let子句、join子 句、orderby子句和group子句，甚至還可以是from子句。它包括8個基本子句，具體說明如下所示。
●from子句：指定查詢操作的數據源和范圍變量。
●select子句：指定查詢結果的類型和表現形式。
●where子句：指定篩選元素的邏輯條件。
●let子句：引入用來臨時保存查詢表達式中的字表達式結果的范圍變量。
●orderby子句：對查詢結果進行排序操作，包括升序和降序。
●group子句：對查詢結果進行分組。
●into子句：提供一個臨時標識符。join子句、group子句或select子句可以通過該標識符引用查詢操作中的中堅結果。
●join子句：連接多個用於查詢操作的數據源。

1.1,select,from, where子句:
示例1
下面創建一個查詢表達式query，該查詢表達式查詢arr數組中的每一個元素。
int[]arr =new int[]{0,1,2,3,4,5,6,7,8,9};

分析1

class Program
{
    static void Main()
    {
        int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        var query = from n in arr
                     select n;
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

示例2
下面創建一個查詢表達式query2.該查詢表達式查詢arr數組中大於6的元素。

class Program
{
    static void Main()
    {
        int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
        var query = from n in arr
                           where n >6
                           select n; 
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析2
變量只是保存查詢操作，而不是查詢的結果。當查詢表達式執行查詢操作時，才會計算該查詢表達式的結果。以上兩個變量的類型都屬於集合類型。

 

示例3
下面創建一個查詢表達式query。該查詢表達式包含兩個from子句，他們分別查詢兩個獨立的數據源；arr1數組和arr2數組。最后，使用select子句計算當前元素的和。

class Program
{
    static void Main()
    {
        int[] arr1= new int[] {0,1,2,3,4,5,6,7,8,9};
        int[] arr2=new int[] {0,1,2,3,4,5,6,7,8,9};
        var query = from a in arr1
                         from b in arr2
                         select a +b;
                     
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析3
包含符合from子句的查詢表達式
在查詢表達式中，有可能查詢表達式的數據源中的每一個元素本身也作為該查詢表達式的數據源。那么要查詢數據源中的每一個元素中的元素，則需要使用符合from子句。符合from子句類似於嵌套的foreach語句。

 

1.2,let子句
let子句用來創建一個新的范圍變量，它用於存儲子表達式的結果。let子句使用編程者提供的表達式的結果初始化該變量。一旦初始化了該范圍變量的值，它就不能用於存儲其他的值。

示例
下面創建一個查詢表達式query。該查詢表達式從arr數組中查詢為偶數的元素。

class Program
{
    static void Main(string[] args)
    {
            int[] arr = new int[] {0,1,2,3,4,5,6,7,8,9};
            var query = from n in arr
                             let isEven = (n % 2 == 0 ? true : false)
                             where isEven 
                             select n;

            foreach (var element in query)
                Console.WriteLine(element);
            Console.ReadKey();
    }
}

分析
"return n%2==0?true:false"表達式判斷n元素是否為偶數。如果是，則返回true，否則返回false。“let isEven =return n%2==0?true:false”表達式使用let子句創建新的范圍變量isEven，用來保存"return n%2==0?true:false"表達式的結果。"where isEven"表達式使用where子句篩選isEven的值為true的元素。

1.3,orderby子句
orderby子句可使返回的查詢結果按升序或者降序排序。升序由關鍵字ascending指定，而降序由關鍵字descending指定。
注意：orderby子句默認排序方式為升序。

示例
下面創建一個查詢表達式query。該查詢表達式從arr數組中查詢大於1且小於6的元素，並且按照n元素對查詢結果進行降序排序。

class Program
{
    static void Main()
    {
        int[] arr = new int[]{0,1,2,3,4,5,6,7,8,9};
        var query = from n in arr
                         where n>1 && n<6
                         orderby n descending
                         select n ;
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析
orderby子句可以包含一個或多個排序表達式，各個排序表達式使用逗號（,）分隔。

1.4, group子句
group子句用來將查詢結果分組，並返回一對象序列。這些對象包含零個或更多個與改組的key值匹配的項，還可以使用group子句結束查詢表達式。
注意：每一個分組都不是單個元素，而是一個序列（也屬於集合）。

示例
下面創建一個查詢表達式query。該查詢表達式從arr數組中查詢大於1且小於6的元素，並且按照n%2表達式的值對查詢結果進行分組。

class Program
{
    static void Main(string[] args)
    {
        int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        var query =  from n in arr
                          where n > 1 && n < 6
                          group n by n % 2;

        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析
query查詢表達式的結果是一個序列（類型為IEnumerable<IGrouping<int,int>>），該序列的元素類型為IGrouping<int,int>.其實，該查詢結果中的元素也是一個序列。

1.5, into子句
下面創建一個查詢表達式query。該查詢表達式從arr數組中查詢大於1且小於6的元素，並且按照n%2表達式的值對查詢結果進行分組。該查詢表達式的具體說明如下所示：
where n>1 && n<6：指定篩選大於1且小於6的元素。
group n by n%2 into g: 按照n%2表達式的值對查詢結果進行分組(0和0一組, 1和1 一組)，並使用into子句創建臨時標識符g。該臨時標識符臨時保存分組結果。
from sn in g：從g標識符指定的每一個分組中查詢sn元素。
select sn：表示查詢sn元素。

class Program
{
    static void Main()
    {
        int[] arr    =    new int[]{0,1,2,3,4,5,6,7,8,9};
        var query  =    from n in arr 
                            where n>1&& n<6
                            group n by n%2 into g
                            from sn in g
                            select sn;
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析
上述查詢表達式的查詢結果包括4個元素，依次為2、4、3和5

1.6, join子句
oin子句用來連接兩個數據源，即設置兩個數據源之間的關系。join子句支持以下3種常見聯接方式。
內部聯接：元素的鏈接關系 必須同時滿足兩個數據源，類似於SQL語句中的inner join子句。
分組聯接：包含into子句的join子句。
左外部聯接：元素的鏈接關系必須滿足聯接中的左數據源，類似於SQL語句中的left join子句。

內部聯接：join子句的內部聯接要求兩個數據源都必須存在相同的值，即兩個數據源都必須存在滿足聯接關系的元素。

示例
下面創建一個查詢表達式query。該查詢表達式使用join子句聯接了arra和arrb數組，具體說明如下。
創建arra數組，它包含10個元素（0~9）。
創建arrb數組，它包含5個元素（0、2、4、6和8）。
創建query查詢。
from a in arra：從arra數組中選擇元素，並表示為a。
where a < 7: 從arra數組中選擇小於7的元素
join b in arrb on a equals b: 將arra和arrb數組進行聯接，同時滿足a和b相等的條件。其中，b元素是arrb數組中的元素。
select a： 選擇a元素。

class Program
{
    static void Main()
    {
        int[] arra    =    new int[] {0,1,2,3,4,5,6,7,8,9};
        int[] arrb    =    new int[]{0,2,4,6,8};
        var query    =    from a  in arra 
                            where a <7
                            join b in arrb on a equals b 
                            select a;
        foreach (var element in query)
            Console.WriteLine(element);
        Console.ReadKey();
    }
}

分析
上述查詢表達式首先選擇小於7的元素，（包括0~6），然后再喝arrb數組進行聯接，並獲取既包含在{0,1,2,3,4,5,6}集合中，又包含在arrb數組中的元素。最終，查詢表達式的結果包含4個元素（0、2、4和6）
分組聯接：join子句的分組聯接包含into子句的join子句的鏈接。它將左數據源與右數據源的元素一次匹配。左數據源的所有元素都出現在查詢結果中。若在右數據源中找到匹配項，則使用匹配的數據，否則用空表示。

 

(2),使用Linq to XML查詢XML文件
在Linq提出之前, 我們可以使用XPath來查詢XML文件, 但是用XPath時必須首先知道XML文件的具體結構, 而使用Linq to XML則不需要知道這些.
而且Linq to XML的代碼還更加簡潔.

class Program
{
    //初始化xml數據
    private static string xmlString =
    "<Persons>" +
    "<Person Id = '1'>" +
    "<Name>Barry Wang</Name>" +
    "<Age>18</Age>" +
    "</Person>" +
    "<Person Id = '2'>" +
    "<Name>Tony Jia</Name>" +
    "<Age>20</Age>" +
    "</Person>" +
    "<Person Id = '3'>" +
    "<Name>Anson Shen</Name>" +
    "<Age>19</Age>" +
    "</Person>" +
    "</Persons>";


    static void Main(string[] args)
    {
        Console.WriteLine("使用Linq方法來對XML文件查詢, 查詢結果是: ");
        UsingLinqLinqToXmlQuery();
        Console.ReadKey();
    }

    //使用Linq來對XML文件進行查詢
    private static void UsingLinqLinqToXmlQuery()
    { 
        //導入XML文件
        XElement xmlDoc = XElement.Parse(xmlString); 

        //創建查詢, 獲取姓名為"李四"的元素
        var queryResults    =  from element in xmlDoc.Elements("Person")
                                    where element.Element("Name").Value == "Barry Wang"
                                    select element;

        //輸出查詢結果
        foreach (var xele in queryResults)
        {
            Console.WriteLine("姓名為: " + xele.Element("Name").Value + "Id為: " + xele.Attribute("Id").Value);
        }
    }
}

Linq to DataSet其實都和Linq to Object 類似, 這里就不在講解了.更多內容在以下兩個鏈接:
MSDN之Linq講解
Linq操作合集

 

2,Lambda表達式
Lambda表達式可以理解為一個匿名方法, 它可以包含表達式和語句, 並且用於創建委托或轉換表達式樹.
在使用Lambda表示式時, 都會使用"=>"運算符(讀作goes to), 該運算符的左邊是匿名方法的輸入參數, 右邊則是表達式或語句塊.

這里主要列舉下Linq和Lambda表達式的一些區別:

LINQ的書寫格式如下： 　
　　from 臨時變量 in 集合對象或數據庫對象 　
　　where 條件表達式 　　
　　[order by條件] 　　
　　select 臨時變量中被查詢的值 　
　　[group by 條件]

Lambda表達式的書寫格式如下：
　　(參數列表) => 表達式或者語句塊

其中：參數個數：可以有多個參數，一個參數，或者無參數。
參數類型：可以隱式或者顯式定義。
表達式或者語句塊：這部分就是我們平常寫函數的實現部分（函數體）。

1.查詢全部

查詢Student表的所有記錄。

select * from student
Linq:
    from s in Students
    select s
Lambda:
    Students.Select( s => s)

2 按條件查詢全部：

查詢Student表中的所有記錄的Sname、Ssex和Class列。

select sname,ssex,class from student
Linq:
    from s in Students
    select new {
        s.SNAME,
        s.SSEX,
        s.CLASS
    }
Lambda:
    Students.Select( s => new {
        SNAME = s.SNAME,SSEX = s.SSEX,CLASS = s.CLASS
    })

3.distinct 去掉重復的

查詢教師所有的單位即不重復的Depart列。

select distinct depart from teacher
Linq:
    from t in Teachers.Distinct()
    select t.DEPART
Lambda:
    Teachers.Distinct().Select( t => t.DEPART)

4.連接查詢 between and

查詢Score表中成績在60到80之間的所有記錄。

select * from score where degree between 60 and 80
Linq:
    from s in Scores
    where s.DEGREE >= 60 && s.DEGREE < 80
    select s
Lambda:
    Scores.Where(
        s => (
                s.DEGREE >= 60 && s.DEGREE < 80
             )
    )

5.在范圍內篩選 In

select * from score where degree in (85,86,88)
Linq:
    from s in Scores
    where (
            new decimal[]{85,86,88}
          ).Contains(s.DEGREE)
    select s
Lambda:
    Scores.Where( s => new Decimal[] {85,86,88}.Contains(s.DEGREE))

6.or 條件過濾

查詢Student表中"95031"班或性別為"女"的同學記錄。

select * from student where class ='95031' or ssex= N'女'
Linq:
    from s in Students
    where s.CLASS == "95031"
       || s.CLASS == "女"
    select s
Lambda:
    Students.Where(s => ( s.CLASS == "95031" || s.CLASS == "女"))

7.排序

以Class降序查詢Student表的所有記錄。

select * from student order by Class DESC
Linq:
    from s in Students
    orderby s.CLASS descending
    select s
Lambda:
    Students.OrderByDescending(s => s.CLASS)

8.count（）行數查詢

select count(*) from student where class = '95031'
Linq:
    (    from s in Students
        where s.CLASS == "95031"
        select s
    ).Count()
Lambda:
    Students.Where( s => s.CLASS == "95031" )
                .Select( s => s)
                    .Count()

 

9.avg()平均

查詢'3-105'號課程的平均分。

select avg(degree) from score where cno = '3-105'
Linq:
    (
        from s in Scores
        where s.CNO == "3-105"
        select s.DEGREE
    ).Average()
Lambda:
    Scores.Where( s => s.CNO == "3-105")
            .Select( s => s.DEGREE).Average()

 

10.子查詢
查詢Score表中的最高分的學生學號和課程號。

select distinct s.Sno,c.Cno from student as s,course as c ,score as sc
where s.sno=(select sno from score where degree = (select max(degree) from score))
and c.cno = (select cno from score where degree = (select max(degree) from score))
Linq:
    (
        from s in Students
        from c in Courses
        from sc in Scores
        let maxDegree = (from sss in Scores
                        select sss.DEGREE
                        ).Max()
        let sno = (from ss in Scores
                where ss.DEGREE == maxDegree
                select ss.SNO).Single().ToString()
        let cno = (from ssss in Scores
                where ssss.DEGREE == maxDegree
                select ssss.CNO).Single().ToString()
        where s.SNO == sno && c.CNO == cno
        select new {
            s.SNO,
            c.CNO
        }
    ).Distinct()

11.分組 過濾

查詢Score表中至少有5名學生選修的並以3開頭的課程的平均分數。

select avg(degree) from score where cno like '3%' group by Cno having count(*)>=5
Linq:
        from s in Scores
        where s.CNO.StartsWith("3")
        group s by s.CNO
        into cc
        where cc.Count() >= 5
        select cc.Average( c => c.DEGREE)
Lambda:
    Scores.Where( s => s.CNO.StartsWith("3") )
            .GroupBy( s => s.CNO )
              .Where( cc => ( cc.Count() >= 5) )
                .Select( cc => cc.Average( c => c.DEGREE) )
Linq: SqlMethod
like也可以這樣寫:
    s.CNO.StartsWith("3") or SqlMethods.Like(s.CNO,"%3")

12.分組

查詢Score表中至少有5名學生選修的並以3開頭的課程的平均分數。

select avg(degree) from score where cno like '3%' group by Cno having count(*)>=5
Linq:
        from s in Scores
        where s.CNO.StartsWith("3")
        group s by s.CNO
        into cc
        where cc.Count() >= 5
        select cc.Average( c => c.DEGREE)
Lambda:
    Scores.Where( s => s.CNO.StartsWith("3") )
            .GroupBy( s => s.CNO )
              .Where( cc => ( cc.Count() >= 5) )
                .Select( cc => cc.Average( c => c.DEGREE) )
Linq: SqlMethod
like也可以這樣寫:
    s.CNO.StartsWith("3") or SqlMethods.Like(s.CNO,"%3")

13. 多表查詢

select sc.sno,c.cname,sc.degree from course as c,score as sc where c.cno = sc.cno
Linq:
    from c in Courses
    join sc in Scores
    on c.CNO equals sc.CNO
    select new
    {
        sc.SNO,c.CNAME,sc.DEGREE
    }
Lambda:
    Courses.Join ( Scores, c => c.CNO,
        sc => sc.CNO,
           (c, sc) => new
           {
            SNO = sc.SNO,
            CNAME = c.CNAME,
            DEGREE = sc.DEGREE
           })

 

14,關聯多條件查詢

感謝@浪子哥 給的建議, 現在加上兩張表的關聯多條件查詢, 只有Linq和Lambda表達式

今天自己又參考園里大神的一些帖子自己寫了一個兩張表關聯查詢的Linq及Lambda表達式的Demo, 大家可以看下.

class Program
    {
        static void Main()
        {
            DataTable tableA = new DataTable();
            tableA.Columns.Add("Name", typeof(string));
            tableA.Columns.Add("Age", typeof(int));
            tableA.Columns.Add("Score", typeof(int));

            DataTable tableB = new DataTable();
            tableB.Columns.Add("Name", typeof(string));
            tableB.Columns.Add("Age", typeof(int));
            tableB.Columns.Add("Score", typeof(int));

            tableA.Rows.Add("Barry", 12, 60);
            tableA.Rows.Add("Tony", 24, 70);
            tableA.Rows.Add("Tom", 22, 80);
            tableA.Rows.Add("Brad", 25, 90);

            tableB.Rows.Add("Kitty", 12, 65);
            tableB.Rows.Add("Tom", 27, 75);
            tableB.Rows.Add("Jhon", 22, 85);
            tableB.Rows.Add("Brad", 21, 95);

            //單表查詢
            var singleQuery = tableA.AsEnumerable().Where(stu => stu.Field<int>("Age") > 20);
            foreach (var item in singleQuery)
            {
                Console.WriteLine("Case 1 query result: Age {0}, Name {1}", item.Field<int>("Age"), 
　　　　　　　　　　　　　　item.Field<string>("Name").ToString());
            }

            //Linq:兩張表的關聯查詢
            var doubleQuery = from a in tableA.AsEnumerable()
                              from b in tableB.AsEnumerable()
                              where a.Field<string>("Name") == b.Field<string>("Name") &&
                              a.Field<int>("Age") != b.Field<int>("Age")
                              orderby a.Field<string>("Name"), a.Field<int>("Score")
                              select new
                              {
                                  Name = a.Field<string>("Name"),
                                  A_Age = a.Field<int>("Age"),
                                  B_Age = b.Field<int>("Age")
                              };
            foreach (var item in doubleQuery)
            {
                Console.WriteLine("Case 2 query result: Name {0}, tableA_Age {1}, tableB_Age {2}",
　　　　　　　　　　　　　　 item.Name, item.A_Age, item.B_Age);
            }

            //Lambda:兩張表的關聯查詢
            var query = tableA.AsEnumerable()
                  .Join(tableB.AsEnumerable(),
                   a => a.Field<string>("Name"),
                   b => b.Field<string>("Name"),
                   (a, b) => new
                   {
                       a = a,
                       b = b
                   })
                  .Where(c => (c.a.Field<int>("Age") != c.b.Field<int>("Age")))
                  .OrderBy(d => d.a.Field<string>("Name"))
                  .ThenBy(e => e.a.Field<int>("Score"))
                  .Select(f => new
                  {
                      Name = f.a.Field<string>("Name"),
                      A_Age = f.a.Field<int>("Age"),
                      B_Age = f.b.Field<int>("Age"),
                      A_Score = f.a.Field<int>("Score"),
                      B_Score = f.a.Field<int>("Score")
                  });
            foreach (var item in query)
            {
                Console.WriteLine("Case 3 query result: Name {0}, tableA_Age {1}, tableB_Age {2}, tableA_Score {3}, 
　　　　　　　　　　　　　　tableB_Score {4}",item.Name, item.A_Age, item.B_Age, item.A_Score, item.B_Score);

 } 74  Console.ReadKey(); 75  } 76     }

解析:

　　首先可以看出來, Lambda表達式對於這種多表多條件的查詢寫法的易讀性明顯沒有Linq高, 所以 還是建議用Linq去寫. 運行結果如下圖: