在說(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;