首先申明這不是我寫的，只是我看到的一篇十分不錯(cuò)的文章，為了防止自己找不到，就整理了下。
一：與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)代替書寫循環(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;
}
}
這段代碼中
- 首先定義了一個(gè)委托類型
delegate Boolean moreOrlessDelgate(int item);
你看到了，委托和類是一個(gè)級(jí)別的，確實(shí)是這樣：
委托是一種類型和class標(biāo)志的類型不一樣，這種類型代表某一類方法。
這一句代碼的意思是：
moreOrlessDelgate這個(gè)類型代表返回值為布爾類型，輸入?yún)?shù)為整形的方法 - 有類型就會(huì)有類型的實(shí)例
var d1 = new moreOrlessDelgate(More);
var d2 = new moreOrlessDelgate(Less);
這兩句就是創(chuàng)建moreOrlessDelgate類型實(shí)例的代碼，它們的輸入?yún)?shù)是兩個(gè)方法
- 有了類型的實(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）使用
- 使用簡(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ù)
- 泛型類型
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è)空值
注意：
- 傳入?yún)?shù)必須為指定的類型，因?yàn)槲覀冊(cè)谑褂眠@個(gè)泛型類型的時(shí)候，已經(jīng)規(guī)定好它能接收什么類型的參數(shù)但在設(shè)計(jì)這個(gè)泛型的時(shí)候，我們并不知道使用者將傳遞什么類型的參數(shù)進(jìn)來(lái)
- 如果你想返回T類型的空值，那么請(qǐng)用default(T)這種形式，因?yàn)槟悴恢繲是值類型還是引用類型，所以別擅自用null
- 泛型約束，很多時(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）泛型的好處
- 算法的重用，想想看：list類型的排序算法，對(duì)所有類型的list集合都是有用的
- 類型安全
- 提升性能，沒(méi)有類型轉(zhuǎn)化了，一方面保證類型安全，另一方面保證性能提升
- 可讀性更好，這一點(diǎn)就不解釋了
7.泛型委托
（1）源起
委托需要定義delgate類型，使用起來(lái)頗多不便，而且委托本就代表某一類方法，開(kāi)發(fā)人員經(jīng)常使用的委托基本可以歸為三類，哪三類呢？請(qǐng)看下面：
（2）使用
- 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è)泛型委托
- 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
}
- 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）好處
代碼可讀性更好。
可以訪問(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 => { 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ō)明
- 過(guò)濾
Where
用法：arr.Where(a => { return a > 3; })，
說(shuō)明：找到集合中滿足指定條件的元素，
OfType
用法：arr.OfType<int>()
說(shuō)明：根據(jù)指定類型，篩選集合中的元素- 投影
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è)序列中，最終把所有的序列合并- 還有很多查詢操作符，請(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]
- 第一行的解釋：type是可選的，id是集合中的一項(xiàng)，source是一個(gè)集合，如果集合中的類型與type指定的類型不同則導(dǎo)致強(qiáng)制轉(zhuǎn)化
- 第二行的解釋：一個(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()
};
- 第三行的解釋：一個(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子句可以指定查詢條件
- 第四行的解釋：一個(gè)查詢表達(dá)式可以有0個(gè)或多個(gè)排序方式，每個(gè)排序方式以逗號(hào)分割
- 第五行的解釋：一個(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()};
- 第六行的解釋：最后一個(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;
轉(zhuǎn)載自：http://www.cnblogs.com/liulun/archive/2013/02/26/2909985.html
