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

一：與LINQ有關(guān)的語言特性

　　1.隱式類型

　　　　（1）源起

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

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

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

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

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

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

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

　　　　（2）使用方法

　　　　?　　來看下面的代碼：　　　　

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

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

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

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

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

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

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

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

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

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

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

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

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

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

　　2.匿名類型

　　　　(1)源起

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

　　　　　　不一定的！

　　　　　　來看看這段代碼

　　　　（2）使用　

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

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

　　　　　　而且，對(duì)象創(chuàng)建出來之后，在創(chuàng)建對(duì)象的方法中，還可以暢通無阻的訪問對(duì)象的屬性

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

　　　　（3）注意　　　　

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

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

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

　　　　　　這個(gè)特性在網(wǎng)站開發(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)用處也沒有，比如對(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ù)

　　　　　　那么代碼看起來就像這樣

　　　　　　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）使用

　　　　　　我們先來看一個(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ù)和返回值是什么類型的，

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

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

　　　　　　沒錯(cuò)！你是對(duì)的！

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

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

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

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

　　　　　　有泛型之后就可以了！

　　　　（2）使用

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

　　　　　　　　先來看下面的代碼：　　　　　　　　

　　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類庫定義好并提供給我們使用的

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

　　　　　　　　來看下面的代碼：　　　　　　　　

　　　　　　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)來

　　　　　　　　　　[2]

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

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

　　　　　　<3>泛型約束

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

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

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

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

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

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

　　　　　　　　代碼如下：　　　　　　　　

　　　　　　　　　　public static class SomethingFactory<T> where T:MyObj

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

　　　　　　　　注意：

　　　　　　　　　　還可以寫成這樣

　　　　　　　　　　where T:MyObj,new()

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

　　　　（3）泛型的好處

　　　　　　<1>算法的重用

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

　　　　　　<2>類型安全

　　　　　　<3>提升性能

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

　　　　　　<4>可讀性更好

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

　　7.泛型委托

　　　　（1）源起

　　　　　　委托需要定義delgate類型

　　　　　　使用起來頗多不便

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

　　　　　　開發(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é)果和原來的結(jié)果是一模一樣的。

　　　　　　　　那么Predicate到底是什么呢？

　　　　　　　　來看看他的定義：　　　　

　　　　　　// 摘要:// 表示定義一組條件并確定指定對(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ù)的類型是不確定的，

　　　　　　　　但不能有返回值，

　　　　　　　　來看個(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 wantreturn string.Empty;}

　　8.匿名方法

　　　　（1）源起

　　　　　　在上面的例子中

　　　　　　為了得到序列中較大的值

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

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

　　　　　　然而這個(gè)方法，沒有太多邏輯（實(shí)際編程過程中，如果邏輯較多，確實(shí)應(yīng)該獨(dú)立一個(gè)方法出來）

　　　　　　那么能不能把More方法中的邏輯，直接寫出來呢？

　　　　　　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){

　　　　　　　　　　//可以訪問當(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>可以訪問當(dāng)前上下文中的變量

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

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

　　　　　　　　想要訪問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)推斷出它是什么類型的，

　　　　　　　　如果沒有輸入?yún)?shù)，可以寫成這樣：

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

　　　　　　<2>

　　　　　　　　=>是lambda操作符

　　　　　　<3>

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

　　　　　　　　如果是多條語句的話，可以用{}包起來。

　　　　　　　　如果需要返回值的話，可以直接寫return語句

　　10.擴(kuò)展方法

　　　　（1）源起

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

　　　　　　不一定的！

　　　　（2）使用

　　　　　　來看看這段代碼：　　　　

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

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

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

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

　　　　　　本來string類型沒有PrintString方法

　　　　　　但通過我們上面的代碼，就給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>如果原來的類中有一個(gè)方法，跟你的擴(kuò)展方法一樣（至少用起來是一樣），那么你的擴(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代碼塊。

　　　　　　來看看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)存中來嗎？

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

　　　　　　來看看這段代碼：　　　　　　

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é)果為：　　　　　　

　　　　　　迭代器返回了11迭代器返回了2

　　　　　　大家可以看到：

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

　　　　　　并沒有輸出“迭代器返回了3”

　　　　　　也就是說下面的工作沒有做。

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

　　　　　　MSDN中的解釋如下：

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

　　　　　　也就是說，我們可以在生成迭代器的時(shí)候，來確定什么時(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)致異常

　　　　　　　　（我在這里犯過錯(cuò)）

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

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

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

　　　　　　　　這些操作，我們接下來會(huì)講到。

二：LINQ

　　1.查詢操作符

　　　　（1）源起

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

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

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

　　　　（2）使用

　　　　　　這一系列的擴(kuò)展方法，比如：

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

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

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

　　　　　　來看看這段代碼：　　　　　　

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é)是完全一樣的

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

　　　　　　第二句代碼中的where，就是我們要說的查詢操作符。

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

　　　　　　<1>過濾

　　　　　　　　Where

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

　　　　　　　　說明：找到集合中滿足指定條件的元素

　　　　　　　　OfType

　　　　　　　　用法：arr.OfType<int>()

　　　　　　　　說明：根據(jù)指定類型，篩選集合中的元素

　　　　　　<2>投影

　　　　　　　　Select

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

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

　　　　　　　　SelectMany

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

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

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

　　2.查詢表達(dá)式

　　　　（1）源起

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

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

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

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

　　　　（2）用法

　　　　　　from v in arr where v > 3 select v

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

　　　　（3）說明：

　　　　　　先看一段偽代碼：　　　　　　

　　　　　　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è)分組，也就是說“一對(duì)多”里的“多”

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

　　　　　　　　比如：　　　　　　　　

　　　　　　　　from c in db.Customersjoin o in db.Orders on c.CustomerIDequals o.CustomerID into ordersselect 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 userslet number = Int32.Parse(u.Username.Substring(u.Username.Length - 1))where u.ID < 9 && number % 2 == 0select 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子句起到的作用是

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

　　　　　　　　比如：　　　　　　　　

　　　　from p in db.Employeesselect new{LastName = p.LastName,TitleOfCourtesy = p.TitleOfCourtesy} into EmployeesListorderby EmployeesList.TitleOfCourtesy ascendingselect EmployeesList;

總結(jié)

以上是生活随笔為你收集整理的由浅到深讲解C#-LINQ的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。