西西軟件園多重安全檢測(cè)下載網(wǎng)站、值得信賴的軟件下載站!
軟件
軟件
文章
搜索

首頁(yè)西西教程數(shù)據(jù)庫(kù)教程 → Linq入門教程詳解

Linq入門教程詳解

相關(guān)軟件相關(guān)文章發(fā)表評(píng)論 來(lái)源:西西整理時(shí)間:2013/7/28 22:38:18字體大小:A-A+

作者:西西點(diǎn)擊:29次評(píng)論:0次標(biāo)簽: Linq

  • 類型:數(shù)據(jù)庫(kù)類大。1.7M語(yǔ)言:英文 評(píng)分:5.0
  • 標(biāo)簽:
立即下載

在說(shuō)LINQ之前必須先說(shuō)說(shuō)幾個(gè)重要的C#語(yǔ)言特性

一:與LINQ有關(guān)的語(yǔ)言特性

1.隱式類型

(1)源起

在隱式類型出現(xiàn)之前,

我們?cè)诼暶饕粋(gè)變量的時(shí)候,

總是要為一個(gè)變量指定他的類型

甚至在foreach一個(gè)集合的時(shí)候,

也要為遍歷的集合的元素,指定變量的類型

隱式類型的出現(xiàn),

程序員就不用再做這個(gè)工作了。

(2)使用方法

 來(lái)看下面的代碼:

var a = 1; //int a = 1;
var b = "123";//string b = "123"; 
var myObj = new MyObj();//MyObj myObj = new MyObj()

上面的每行代碼,與每行代碼后面的注釋,起到的作用是完全一樣的

也就是說(shuō),在聲明一個(gè)變量(并且同時(shí)給它賦值)的時(shí)候,完全不用指定變量的類型,只要一個(gè)var就解決問(wèn)題了

(3)你擔(dān)心這樣寫會(huì)降低性能嗎?

我可以負(fù)責(zé)任的告訴你,這樣寫不會(huì)影響性能!

上面的代碼和注釋里的代碼,編譯后產(chǎn)生的IL代碼(中間語(yǔ)言代碼)是完全一樣的

(編譯器根據(jù)變量的值,推導(dǎo)出變量的類型,才產(chǎn)生的IL代碼)

(4)這個(gè)關(guān)鍵字的好處:

你不用在聲明一個(gè)變量并給這個(gè)變量賦值的時(shí)候,寫兩次變量類型

(這一點(diǎn)真的為開(kāi)發(fā)者節(jié)省了很多時(shí)間)

在foreach一個(gè)集合的時(shí)候,可以使用var關(guān)鍵字來(lái)代替書(shū)寫循環(huán)變量的類型

(5)注意事項(xiàng)

你不能用var關(guān)鍵字聲明一個(gè)變量而不給它賦值

因?yàn)榫幾g器無(wú)法推導(dǎo)出你這個(gè)變量是什么類型的。

2.匿名類型

(1)源起

創(chuàng)建一個(gè)對(duì)象,一定要先定義這個(gè)對(duì)象的類型嗎?

不一定的!

來(lái)看看這段代碼

(2)使用 

         var obj = new {Guid.Empty, myTitle = "匿名類型", myOtherParam = new int[] { 1, 2, 3, 4 } };
         Console.WriteLine(obj.Empty);//另一個(gè)對(duì)象的屬性名字,被原封不動(dòng)的拷貝到匿名對(duì)象中來(lái)了。
         Console.WriteLine(obj.myTitle);
         Console.ReadKey();

new關(guān)鍵字之后就直接為對(duì)象定義了屬性,并且為這些屬性賦值

而且,對(duì)象創(chuàng)建出來(lái)之后,在創(chuàng)建對(duì)象的方法中,還可以暢通無(wú)阻的訪問(wèn)對(duì)象的屬性

當(dāng)把一個(gè)對(duì)象的屬性拷貝到匿名對(duì)象中時(shí),可以不用顯示的指定屬性的名字,這時(shí)原始屬性的名字會(huì)被“拷貝”到匿名對(duì)象中

(3)注意

如果你監(jiān)視變量obj,你會(huì)發(fā)現(xiàn),obj的類型是Anonymous Type類型的

不要試圖在創(chuàng)建匿名對(duì)象的方法外面去訪問(wèn)對(duì)象的屬性!

(4)優(yōu)點(diǎn)

這個(gè)特性在網(wǎng)站開(kāi)發(fā)中,序列化和反序列化JSON對(duì)象時(shí)很有用

3.自動(dòng)屬性

(1)源起

為一個(gè)類型定義屬性,我們一般都寫如下的代碼:

    public class MyObj2
    {
        private Guid _id;
        private string _Title;
        public Guid id 
        {
            get { return _id; }
            set { _id = value; } 
        }
        public string Title
        {
            get { return _Title; }
            set { _Title = value; }
        }
    }

但很多時(shí)候,這些私有變量對(duì)我們一點(diǎn)用處也沒(méi)有,比如對(duì)象關(guān)系映射中的實(shí)體類。

自C#3.0引入了自動(dòng)實(shí)現(xiàn)的屬性,

以上代碼可以寫成如下形式:

(2)使用

    public class MyObj
    {
        public Guid id { get; set; }
        public string Title { get; set; }
    }

這個(gè)特性也和var關(guān)鍵字一樣,是編譯器幫我們做了工作,不會(huì)影響性能的

4.初始化器

(1)源起

我們創(chuàng)建一個(gè)對(duì)象并給對(duì)象的屬性賦值,代碼一般寫成下面的樣子

            var myObj = new MyObj();
            myObj.id = Guid.NewGuid();
            myObj.Title = "allen";

自C#3.0引入了對(duì)象初始化器,

代碼可以寫成如下的樣子

(2)使用

var myObj1 = new MyObj() { id = Guid.NewGuid(), Title = "allen" };

如果一個(gè)對(duì)象是有參數(shù)的構(gòu)造函數(shù)

那么代碼看起來(lái)就像這樣

var myObj1 = new MyObj ("allen") { id = Guid.NewGuid(), Title = "allen" };

集合初始化器的樣例代碼如下:

var arr = new List<int>() { 1, 2, 3, 4, 5, 6 };

(3)優(yōu)點(diǎn)

我個(gè)人認(rèn)為:這個(gè)特性不是那么amazing,

這跟我的編碼習(xí)慣有關(guān),集合初始化器也就罷了,

真的不習(xí)慣用對(duì)象初始化器初始化一個(gè)對(duì)象!

5.委托

(1)使用

我們先來(lái)看一個(gè)簡(jiǎn)單的委托代碼

    delegate Boolean moreOrlessDelgate(int item);
    class Program
    {
        static void Main(string[] args)
        {
            var arr = new List<int>() { 1, 2, 3, 4, 5, 6,7,8 };
            var d1 = new moreOrlessDelgate(More);            
            Print(arr, d1);
            Console.WriteLine("OK");

            var d2 = new moreOrlessDelgate(Less);
            Print(arr, d2);
            Console.WriteLine("OK");
            Console.ReadKey();

        }
        static void Print(List<int> arr,moreOrlessDelgate dl)
        {
            foreach (var item in arr)
            {
                if (dl(item))
                {
                    Console.WriteLine(item);
                }
            }
        }
        static bool More(int item)
        {
            if (item > 3)
            { 
                return true; 
            }
            return false;
        }
        static bool Less(int item)
        {
            if (item < 3)
            {
                return true;
            }
            return false;
        }
    }

這段代碼中

<1>首先定義了一個(gè)委托類型

delegate Boolean moreOrlessDelgate(int item);

你看到了,委托和類是一個(gè)級(jí)別的,確實(shí)是這樣:委托是一種類型

和class標(biāo)志的類型不一樣,這種類型代表某一類方法。

這一句代碼的意思是:moreOrlessDelgate這個(gè)類型代表返回值為布爾類型,輸入?yún)?shù)為整形的方法

<2>有類型就會(huì)有類型的實(shí)例

var d1 = new moreOrlessDelgate(More);   
var d2 = new moreOrlessDelgate(Less);

這兩句就是創(chuàng)建moreOrlessDelgate類型實(shí)例的代碼,

它們的輸入?yún)?shù)是兩個(gè)方法

<3>有了類型的實(shí)例,就會(huì)有操作實(shí)例的代碼 

Print(arr, d1);
Print(arr, d2);

我們把前面兩個(gè)實(shí)例傳遞給了Print方法

這個(gè)方法的第二個(gè)參數(shù)就是moreOrlessDelgate類型的

在Print方法內(nèi)用如下代碼,調(diào)用委托類型實(shí)例所指向的方法

dl(item)

6.泛型

(1)為什么要有泛型

假設(shè)你是一個(gè)方法的設(shè)計(jì)者,

這個(gè)方法有一個(gè)傳入?yún)?shù),有一個(gè)返回值。

但你并不知道這個(gè)參數(shù)和返回值是什么類型的,

如果沒(méi)有泛型,你可能把參數(shù)和返回值的類型都設(shè)定為Object了

那時(shí),你心里肯定在想:反正一切都是對(duì)象,一切的基類都是Object

沒(méi)錯(cuò)!你是對(duì)的!

這個(gè)方法的消費(fèi)者,會(huì)把他的對(duì)象傳進(jìn)來(lái)(有可能會(huì)做一次裝箱操作)

并且得到一個(gè)Object的返回值,他再把這個(gè)返回值強(qiáng)制類型轉(zhuǎn)化為他需要的類型

除了裝箱和類型轉(zhuǎn)化時(shí)的性能損耗外,代碼工作的很好!

那么這些新能損耗能避免掉嗎?

有泛型之后就可以了!

(2)使用

<1>使用簡(jiǎn)單的泛型

先來(lái)看下面的代碼:

            var intList = new List<int>() { 1,2,3};
            intList.Add(4);
            intList.Insert(0, 5);
            foreach (var item in intList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

在上面這段代碼中我們聲明了一個(gè)存儲(chǔ)int類型的List容器

并循環(huán)打印出了容器里的值

注意:如果這里使用Hashtable、Queue或者Stack等非泛型的容器

就會(huì)導(dǎo)致裝箱操作,損耗性能。因?yàn)檫@些容器只能存儲(chǔ)Object類型的數(shù)據(jù)

<2>泛型類型

List<T>、Dictionary<TKey, TValue>等泛型類型都是.net類庫(kù)定義好并提供給我們使用的

但在實(shí)際開(kāi)發(fā)中,我們也經(jīng)常需要定義自己的泛型類型

來(lái)看下面的代碼:

    public static class SomethingFactory<T>
    {
        public static T InitInstance(T inObj)
        {
            if (false)//你的判斷條件
            {
                //do what you want...
                return inObj;
            }
            return default(T);
        }
    }

這段代碼的消費(fèi)者如下:

            var a1 = SomethingFactory<int>.InitInstance(12);
            Console.WriteLine(a1);
            Console.ReadKey();

輸出的結(jié)果為0

這就是一個(gè)自定義的靜態(tài)泛型類型,

此類型中的靜態(tài)方法InitInstance對(duì)傳入的參數(shù)做了一個(gè)判斷

如果條件成立,則對(duì)傳入?yún)?shù)進(jìn)行操作之后并把它返回

如果條件不成立,則返回一個(gè)空值

注意:

[1]

傳入?yún)?shù)必須為指定的類型,

因?yàn)槲覀冊(cè)谑褂眠@個(gè)泛型類型的時(shí)候,已經(jīng)規(guī)定好它能接收什么類型的參數(shù)

但在設(shè)計(jì)這個(gè)泛型的時(shí)候,我們并不知道使用者將傳遞什么類型的參數(shù)進(jìn)來(lái)

[2]

如果你想返回T類型的空值,那么請(qǐng)用default(T)這種形式

因?yàn)槟悴恢繲是值類型還是引用類型,所以別擅自用null

<3>泛型約束

很多時(shí)候我們不希望使用者太過(guò)自由

我們希望他們?cè)谑褂梦覀冊(cè)O(shè)計(jì)的泛型類型時(shí)

不要很隨意的傳入任何類型

對(duì)于泛型類型的設(shè)計(jì)者來(lái)說(shuō),要求使用者傳入指定的類型是很有必要的

因?yàn)槲覀冎挥兄浪麄魅肓耸裁礀|西,才方便對(duì)這個(gè)東西做操作

讓我們來(lái)給上面設(shè)計(jì)的泛型類型加一個(gè)泛型約束

代碼如下:

public static class SomethingFactory<T> where T:MyObj

這樣在使用SomethingFactory的時(shí)候就只能傳入MyObj類型或MyObj的派生類型啦

注意:

還可以寫成這樣

where T:MyObj,new()

來(lái)約束傳入的類型必須有一個(gè)構(gòu)造函數(shù)。

(3)泛型的好處

<1>算法的重用

想想看:list類型的排序算法,對(duì)所有類型的list集合都是有用的

<2>類型安全

<3>提升性能

沒(méi)有類型轉(zhuǎn)化了,一方面保證類型安全,另一方面保證性能提升

<4>可讀性更好

這一點(diǎn)就不解釋了 

7.泛型委托

(1)源起

委托需要定義delgate類型

使用起來(lái)頗多不便

而且委托本就代表某一類方法

開(kāi)發(fā)人員經(jīng)常使用的委托基本可以歸為三類,

哪三類呢?

請(qǐng)看下面:

(2)使用

<1>Predicate泛型委托

把上面例子中d1和d2賦值的兩行代碼改為如下:

            //var d1 = new moreOrlessDelgate(More);
            var d1 = new Predicate<int>(More);

            //var d2 = new moreOrlessDelgate(Less);
            var d2 = new Predicate<int>(Less);

把Print方法的方法簽名改為如下:

        //static void Print(List<int> arr, moreOrlessDelgate<int> dl)
        static void Print(List<int> arr, Predicate<int> dl)

然后再運(yùn)行方法,控制臺(tái)輸出的結(jié)果和原來(lái)的結(jié)果是一模一樣的。

那么Predicate到底是什么呢?

來(lái)看看他的定義:

    // 摘要:
    //     表示定義一組條件并確定指定對(duì)象是否符合這些條件的方法。
    //
    // 參數(shù):
    //   obj:
    //     要按照由此委托表示的方法中定義的條件進(jìn)行比較的對(duì)象。
    //
    // 類型參數(shù):
    //   T:
    //     要比較的對(duì)象的類型。
    //
    // 返回結(jié)果:
    //     如果 obj 符合由此委托表示的方法中定義的條件,則為 true;否則為 false。
    public delegate bool Predicate<in T>(T obj);

看到這個(gè)定義,我們大致明白了。

.net為我們定義了一個(gè)委托,

這個(gè)委托表示的方法需要傳入一個(gè)T類型的參數(shù),并且需要返回一個(gè)bool類型的返回值

有了它,我們就不用再定義moreOrlessDelgate委托了,

而且,我們定義的moreOrlessDelgate只能搞int類型的參數(shù),

Predicate卻不一樣,它可以搞任意類型的參數(shù)

但它規(guī)定的還是太死了,它必須有一個(gè)返回值,而且必須是布爾類型的,同時(shí),它必須有一個(gè)輸入?yún)?shù)

除了Predicate泛型委托,.net還為我們定義了Action和Func兩個(gè)泛型委托

<2>Action泛型委托

Action泛型委托限制的就不那么死了,

他代表了一類方法:

可以有0個(gè)到16個(gè)輸入?yún)?shù),

輸入?yún)?shù)的類型是不確定的,

但不能有返回值,

來(lái)看個(gè)例子:

            var d3 = new Action(noParamNoReturnAction);
            var d4 = new Action<int, string>(twoParamNoReturnAction);

 注意:尖括號(hào)中int和string為方法的輸入?yún)?shù)

        static void noParamNoReturnAction()
        {
            //do what you want
        }
        static void twoParamNoReturnAction(int a, string b)
        {
            //do what you want
        }

<3>Func泛型委托

為了彌補(bǔ)Action泛型委托,不能返回值的不足

.net提供了Func泛型委托,

相同的是它也是最多0到16個(gè)輸入?yún)?shù),參數(shù)類型由使用者確定

不同的是它規(guī)定要有一個(gè)返回值,返回值的類型也由使用者確定

如下示例:

var d5 = new Func<int, string>(oneParamOneReturnFunc);

注意:string類型(最后一個(gè)泛型類型)是方法的返回值類型

        static string oneParamOneReturnFunc(int a)
        {
            //do what you want
            return string.Empty;
        }

8.匿名方法

(1)源起

在上面的例子中

為了得到序列中較大的值

我們定義了一個(gè)More方法

var d1 = new Predicate<int>(More);

然而這個(gè)方法,沒(méi)有太多邏輯(實(shí)際編程過(guò)程中,如果邏輯較多,確實(shí)應(yīng)該獨(dú)立一個(gè)方法出來(lái))

那么能不能把More方法中的邏輯,直接寫出來(lái)呢?

C#2.0之后就可以了,

請(qǐng)看下面的代碼:

(2)使用

            var arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 };
            //var d1 = new moreOrlessDelgate(More);
            //var d1 = new Predicate<int>(More);
            var d1 = new Predicate<int>(delegate(int item)
            {

//可以訪問(wèn)當(dāng)前上下文中的變量
Console.WriteLine(arr.Count);

                if (item > 3)

                {
                    return true;
                }
                return false;
            });
            Print(arr, d1);
            Console.WriteLine("OK");

我們傳遞了一個(gè)代碼塊給Predicate的構(gòu)造函數(shù)

其實(shí)這個(gè)代碼塊就是More函數(shù)的邏輯

(3)好處

<1>代碼可讀性更好

<2>可以訪問(wèn)當(dāng)前上下文中的變量

這個(gè)用處非常大,

如果我們?nèi)耘f用原來(lái)的More函數(shù)

想要訪問(wèn)arr變量,勢(shì)必要把a(bǔ)rr寫成類級(jí)別的私有變量了

用匿名函數(shù)的話,就不用這么做了。

9.Lambda表達(dá)式

(1)源起

.net的設(shè)計(jì)者發(fā)現(xiàn)在使用匿名方法時(shí),

仍舊有一些多余的字母或單詞的編碼工作

比如delegate關(guān)鍵字

于是進(jìn)一步簡(jiǎn)化了匿名方法的寫法

(2)使用

            List<int> arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };
            arr.ForEach(new Action<int>(delegate(int a) { Console.WriteLine(a); }));
            arr.ForEach(new Action<int>(a => Console.WriteLine(a)));

 匿名方法的代碼如下:

delegate(int a) { Console.WriteLine(a); }

使用lambda表達(dá)式的代碼如下:

a => Console.WriteLine(a)

這里解釋一下這個(gè)lambda表達(dá)式

<1>

a是輸入?yún)?shù),編譯器可以自動(dòng)推斷出它是什么類型的,

如果沒(méi)有輸入?yún)?shù),可以寫成這樣:

() => Console.WriteLine("ddd")

<2>

=>是lambda操作符

<3>

Console.WriteLine(a)是要執(zhí)行的語(yǔ)句。

如果是多條語(yǔ)句的話,可以用{}包起來(lái)。

如果需要返回值的話,可以直接寫return語(yǔ)句

10.擴(kuò)展方法

(1)源起

如果想給一個(gè)類型增加行為,一定要通過(guò)繼承的方式實(shí)現(xiàn)嗎?

不一定的!

(2)使用

來(lái)看看這段代碼:

        public static void PrintString(this String val)
        {
            Console.WriteLine(val);
        }

消費(fèi)這段代碼的代碼如下:

            var a = "aaa";
            a.PrintString();
            Console.ReadKey();

我想你看到擴(kuò)展方法的威力了。

本來(lái)string類型沒(méi)有PrintString方法

但通過(guò)我們上面的代碼,就給string類型"擴(kuò)展"了一個(gè)PrintString方法

(1)先決條件

<1>擴(kuò)展方法必須在一個(gè)非嵌套、非泛型的靜態(tài)類中定義

<2>擴(kuò)展方法必須是一個(gè)靜態(tài)方法

<3>擴(kuò)展方法至少要有一個(gè)參數(shù)

<4>第一個(gè)參數(shù)必須附加this關(guān)鍵字作為前綴

<5>第一個(gè)參數(shù)不能有其他修飾符(比如ref或者out)

<6>第一個(gè)參數(shù)不能是指針類型

(2)注意事項(xiàng)

<1>跟前面提到的幾個(gè)特性一樣,擴(kuò)展方法只會(huì)增加編譯器的工作,不會(huì)影響性能(用繼承的方式為一個(gè)類型增加特性反而會(huì)影響性能)

<2>如果原來(lái)的類中有一個(gè)方法,跟你的擴(kuò)展方法一樣(至少用起來(lái)是一樣),那么你的擴(kuò)展方法獎(jiǎng)不會(huì)被調(diào)用,編譯器也不會(huì)提示你

<3>擴(kuò)展方法太強(qiáng)大了,會(huì)影響架構(gòu)、模式、可讀性等等等等....

11.迭代器

·(1)使用

我們每次針對(duì)集合類型編寫foreach代碼塊,都是在使用迭代器

這些集合類型都實(shí)現(xiàn)了IEnumerable接口

都有一個(gè)GetEnumerator方法

但對(duì)于數(shù)組類型就不是這樣

編譯器把針對(duì)數(shù)組類型的foreach代碼塊

替換成了for代碼塊。

來(lái)看看List的類型簽名:

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

IEnumerable接口,只定義了一個(gè)方法就是:

IEnumerator<T> GetEnumerator();

(2)迭代器的優(yōu)點(diǎn):

假設(shè)我們需要遍歷一個(gè)龐大的集合

只要集合中的某一個(gè)元素滿足條件

就完成了任務(wù)

你認(rèn)為需要把這個(gè)龐大的集合全部加載到內(nèi)存中來(lái)嗎?

當(dāng)然不用(C#3.0之后就不用了)!

來(lái)看看這段代碼:

        static IEnumerable<int> GetIterator()
        {
            Console.WriteLine("迭代器返回了1");
            yield return 1;
            Console.WriteLine("迭代器返回了2");
            yield return 2;
            Console.WriteLine("迭代器返回了3");
            yield return 3;
        }

消費(fèi)這個(gè)函數(shù)的代碼如下:

            foreach (var i in GetIterator())
            {
                if (i == 2)
                {
                    break;
                }
                Console.WriteLine(i);
            }
            Console.ReadKey();

 輸出結(jié)果為:

迭代器返回了1
1
迭代器返回了2

大家可以看到:

當(dāng)?shù)鞣祷?之后,foreach就退出了

并沒(méi)有輸出“迭代器返回了3”

也就是說(shuō)下面的工作沒(méi)有做。

(3)yield 關(guān)鍵字

MSDN中的解釋如下:

在迭代器塊中用于向枚舉數(shù)對(duì)象提供值或發(fā)出迭代結(jié)束信號(hào)。

也就是說(shuō),我們可以在生成迭代器的時(shí)候,來(lái)確定什么時(shí)候終結(jié)迭代邏輯

上面的代碼可以改成如下形式:

        static IEnumerable<int> GetIterator()
        {
            Console.WriteLine("迭代器返回了1");
            yield return 1;
            Console.WriteLine("迭代器返回了2");
            yield break;
            Console.WriteLine("迭代器返回了3");
            yield return 3;
        }

 (4)注意事項(xiàng)

<1>做foreach循環(huán)時(shí)多考慮線程安全性

在foreach時(shí)不要試圖對(duì)被遍歷的集合進(jìn)行remove和add等操作

任何集合,即使被標(biāo)記為線程安全的,在foreach的時(shí)候,增加項(xiàng)和移除項(xiàng)的操作都會(huì)導(dǎo)致異常

(我在這里犯過(guò)錯(cuò))

<2>IEnumerable接口是LINQ特性的核心接口

只有實(shí)現(xiàn)了IEnumerable接口的集合

才能執(zhí)行相關(guān)的LINQ操作,比如select,where等

這些操作,我們接下來(lái)會(huì)講到。

二:LINQ

1.查詢操作符

(1)源起

.net的設(shè)計(jì)者在類庫(kù)中定義了一系列的擴(kuò)展方法

來(lái)方便用戶操作集合對(duì)象

這些擴(kuò)展方法構(gòu)成了LINQ的查詢操作符

(2)使用

這一系列的擴(kuò)展方法,比如:

Where,Max,Select,Sum,Any,Average,All,Concat等

都是針對(duì)IEnumerable的對(duì)象進(jìn)行擴(kuò)展的

也就是說(shuō),只要實(shí)現(xiàn)了IEnumerable接口,就可以使用這些擴(kuò)展方法

來(lái)看看這段代碼:

            List<int> arr = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };
            var result = arr.Where(a => { return a > 3; }).Sum();
            Console.WriteLine(result);
            Console.ReadKey();

這段代碼中,用到了兩個(gè)擴(kuò)展方法。

<1>

Where擴(kuò)展方法,需要傳入一個(gè)Func<int,bool>類型的泛型委托

這個(gè)泛型委托,需要一個(gè)int類型的輸入?yún)?shù)和一個(gè)布爾類型的返回值

我們直接把a(bǔ) => { return a > 3; }這個(gè)lambda表達(dá)式傳遞給了Where方法

a就是int類型的輸入?yún)?shù),返回a是否大于3的結(jié)果。

<2>

Sum擴(kuò)展方法計(jì)算了Where擴(kuò)展方法返回的集合的和。

(3)好處

上面的代碼中

arr.Where(a => { return a > 3; }).Sum();

這一句完全可以寫成如下代碼:

(from v in arr where v > 3 select v).Sum();

而且兩句代碼的執(zhí)行細(xì)節(jié)是完全一樣的

大家可以看到,第二句代碼更符合語(yǔ)義,更容易讀懂

第二句代碼中的where,就是我們要說(shuō)的查詢操作符。

(4)標(biāo)準(zhǔn)查詢操作符說(shuō)明

<1>過(guò)濾

Where

用法:arr.Where(a => { return a > 3; })

說(shuō)明:找到集合中滿足指定條件的元素

OfType

用法:arr.OfType<int>()

說(shuō)明:根據(jù)指定類型,篩選集合中的元素

<2>投影

Select

用法:arr.Select<int, string>(a => a.ToString());

說(shuō)明:將集合中的每個(gè)元素投影的新集合中。上例中:新集合是一個(gè)IEnumerable<String>的集合

SelectMany

用法:arr.SelectMany<int, string>(a => { return new List<string>() { "a", a.ToString() }; });

說(shuō)明:將序列的每個(gè)元素投影到一個(gè)序列中,最終把所有的序列合并

<3>還有很多查詢操作符,請(qǐng)翻MSDN,以后有時(shí)間我將另起一篇文章把這些操作符寫全。

2.查詢表達(dá)式

(1)源起

上面我們已經(jīng)提到,使用查詢操作符表示的擴(kuò)張方法來(lái)操作集合

雖然已經(jīng)很方便了,但在可讀性和代碼的語(yǔ)義來(lái)考慮,仍有不足

于是就產(chǎn)生了查詢表達(dá)式的寫法。

雖然這很像SQL語(yǔ)句,但他們卻有著本質(zhì)的不同。

(2)用法

from v in arr where v > 3 select v

這就是一個(gè)非常簡(jiǎn)單的查詢表達(dá)式

(3)說(shuō)明:

先看一段偽代碼:

from [type] id in source
[join [type] id in source on expr equals expr [into subGroup]]
[from [type] id in source | let id = expr | where condition]
[orderby ordering,ordering,ordering...]
select expr | group expr by key
[into id query]

<1>第一行的解釋:

type是可選的,

id是集合中的一項(xiàng),

source是一個(gè)集合,

如果集合中的類型與type指定的類型不同則導(dǎo)致強(qiáng)制轉(zhuǎn)化

<2>第二行的解釋:

一個(gè)查詢表達(dá)式中可以有0個(gè)或多個(gè)join子句,

這里的source可以不等于第一句中的source

expr可以是一個(gè)表達(dá)式

[into subGroup] subGroup是一個(gè)中間變量,

它繼承自IGrouping,代表一個(gè)分組,也就是說(shuō)“一對(duì)多”里的“多”

可以通過(guò)這個(gè)變量得到這一組包含的對(duì)象個(gè)數(shù),以及這一組對(duì)象的鍵

比如:

from c in db.Customers

        join o in db.Orders on c.CustomerID
        equals o.CustomerID into orders
        select new
        {
            c.ContactName,
            OrderCount = orders.Count()
        };

<3>第三行的解釋: 

一個(gè)查詢表達(dá)式中可以有1個(gè)或多個(gè)from子句

一個(gè)查詢表達(dá)式中可以有0個(gè)或多個(gè)let子句,let子句可以創(chuàng)建一個(gè)臨時(shí)變量

比如:

        from u in users
         let number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))
         where u.ID < 9 && number % 2 == 0
         select u

一個(gè)查詢表達(dá)式中可以有0個(gè)或多個(gè)where子句,where子句可以指定查詢條件

<4>第四行的解釋:

一個(gè)查詢表達(dá)式可以有0個(gè)或多個(gè)排序方式

每個(gè)排序方式以逗號(hào)分割

<5>第五行的解釋:

一個(gè)查詢表達(dá)式必須以select或者group by結(jié)束

select后跟要檢索的內(nèi)容

group by 是對(duì)檢索的內(nèi)容進(jìn)行分組

比如:

        from p in db.Products  
        group p by p.CategoryID into g  
        select new {  g.Key, NumProducts = g.Count()}; 

<6>第六行的解釋:

最后一個(gè)into子句起到的作用是

將前面語(yǔ)句的結(jié)果作為后面語(yǔ)句操作的數(shù)據(jù)源

比如:

        from p in db.Employees
         select new
         {
             LastName = p.LastName,
             TitleOfCourtesy = p.TitleOfCourtesy
         } into EmployeesList
         orderby EmployeesList.TitleOfCourtesy ascending
         select EmployeesList;

    相關(guān)評(píng)論

    閱讀本文后您有什么感想? 已有人給出評(píng)價(jià)!

    • 8 喜歡喜歡
    • 3 頂
    • 1 難過(guò)難過(guò)
    • 5 囧
    • 3 圍觀圍觀
    • 2 無(wú)聊無(wú)聊

    熱門評(píng)論

    最新評(píng)論

    發(fā)表評(píng)論 查看所有評(píng)論(0)

    昵稱:
    表情: 高興 可 汗 我不要 害羞 好 下下下 送花 屎 親親
    字?jǐn)?shù): 0/500 (您的評(píng)論需要經(jīng)過(guò)審核才能顯示)