1. IEnumerable 與 IEnumerator
IEnumerable枚舉器接口的重要性，說一萬句話都不過分。幾乎所有集合都實現了這個接口，Linq的核心也依賴於這個萬能的接口。C語言的for循環寫得心煩，foreach就順暢了很多。
IEnumerable只有一個抽象方法：GetEnumerator()，而IEnumerator又是一個迭代器接口，真正實現了訪問集合的功能。 IEnumerator只有一個Current屬性，兩個方法MoveNext和Reset。
有個小問題，只搞一個訪問器接口不就得了？為什么要兩個看起來很容易混淆的接口呢？一個叫枚舉器，另一個叫迭代器。因為
(1) 實現IEnumerator是個臟活累活，白白加了兩個方法一個屬性，而且這兩個方法其實並不好實現（后面會提到）。
(2) 它需要維護初始狀態，知道如何Move,如何結束，同時返回迭代的上一個狀態，這些並不容易。
(3)迭代顯然是非線程安全的，每次IEnumerable都會生成新的IEnumerator，從而形成多個互相不影響的迭代過程。在迭代過程中，不能修改迭代集合，否則不安全。
所以只要你實現了IEnumerable，編譯器就會幫我們實現IEnumerator。何況絕大多數情況都是從現有集合繼承，一般不需要重寫MoveNext和Reset方法。 IEnumerable當然還有泛型實現，這個不影響問題的討論。
IEnumerable讓我們想起了單向鏈表，C中需要一個指針域保存下一個節點的信息，那么在IEnumerable中，誰幫忙保存了這個信息？這個過程占用內存么？ 是占在程序區，還是堆區？
反正你知道，如果在某個過程中再調用一次IEnumerable的枚舉，枚舉其實是從頭開始的。所以，每次枚舉，生成的都是新的IEnumerator對象。
但是，IEnumerable也有它致命的缺點，它沒法后退（確實是單向的），沒法跳躍（只能一個一個的跳過去），而且實現Reset並不容易。想想看， 如果是一個實例集合的枚舉過程，直接返回到第0個元素就可以了，但是如果這個IEnumerable是漫長的訪問鏈條，想找到最初的根，難度如何之大！所 以CLR via C#的作者告訴你，其實很多Reset的實現根本就是謊言，知道有這個東西就行了，不要太過依賴它。
2. foreach和MoveNext有區別嗎
IEnumerable最大的特點是將訪問的過程，交給了被訪問者本身控制。在C語言中數組控制權是外部完全掌握的。這個接口卻在內部封裝訪問了的過程，進一步提升了封裝性。比如下面：
public class People //定義一個簡單的實體類 { public string Name { get; set; } public int Age { get; set; } } public class PersonList { private readonly List<People> peoples; public PersonList() //為了方便，構造過程中插入元素 { peoples = new List<People>(); for (int i = 0; i < 5; i++) { peoples.Add(new People {Name = "P" + i, Age = 30 + i}); } } public int OldAge = 31;
public IEnumerable<People> OlderPeoples
{
get
{
foreach (People people in _people)
{
if (people.Age > OldAge)
yield return people;
}
yield break;
}
} }
IEnumerable的本質是狀態機，它有點類似事件的概念，將實現丟到外面，實現代碼間的穿越（想想星際穿越），實現了訪問鏈，這是Linq的基礎。酷炫的迭代器，真的有我們想象的那么簡單么？
在C語言中，數組就是數組，實實在在的內存空間，那么IEnumerable到底是什么意思呢？如果它由一個真正的集合（比如List）實現，那么沒問題，也是實實在在的內存，可是如果是上述的例子呢？篩選返回的yield return 只返回了元素，但可能並不存在這個實際的集合，想到這里，你肯定明白，這個接口代表了一種“狀態”。如果你將簡單的枚舉器的yield return 反編譯后看，會發現其實是一組switch-case, 編譯器在后台為我們做了大量的工作。
生成的新迭代器，如果不MoveNext，其實Current是空的，這是為什么呢？為什么一個迭代器不直接指向頭元素呢？（留給大家思考，我也沒想清楚）
foreach每次往前移動一格，到頭了就停止。 等等，你確定它到頭了就會停止么？我們來做個試驗：
public IEnumerable<People> Peoples1 //直接返回集合 { get { return peoples; } } public IEnumerable<People> Peoples2 //沒有yield break; { get { foreach (var people in peoples) { yield return people; } } } public IEnumerable<People> Peoples3 //包含yield break; { get { foreach (var people in peoples) { yield return people; } yield break; } }
以上三種，是我們常見的方式，注意第三種實現，ReSharper把yield break標成灰色（重復），真的是沒有必要的么？
我們再寫下如下的測試代碼，peopleList集合只有五個元素，但嘗試去MoveNext 8次。可以把peopleList.Peoples1換成2,3，分別測試。
var peopleList = new PeopleList(); //內部構造函數插入了五個元素 IEnumerator<People> e1 = peopleList.Peoples1.GetEnumerator(); if (e1.Current == null) { Console.WriteLine("迭代器生成后Current為空"); } int i = 0; while (i<8) //總共只有五個元素，看看一直迭代會發生什么效果 { e1.MoveNext(); if (e1.Current == null) { Console.WriteLine("迭代第{0}次后為空",i); } else { Console.WriteLine("迭代第{0}次后為{1}",i,e1.Current.Name); } i++; }
//PeopleEnumerable1 (直接返回集合) 迭代器生成后Current為空 迭代第0次后為P0 迭代第1次后為P1 迭代第2次后為P2 迭代第3次后為P3 迭代第4次后為P4 迭代第5次后為空 迭代第6次后為空 迭代第7次后為空 //PeopleEnumerable2 （不加yield break） 迭代器生成后Current為空 迭代第0次后為P0 迭代第1次后為P1 迭代第2次后為P2 迭代第3次后為P3 迭代第4次后為P4 迭代第5次后為P4 迭代第6次后為P4 迭代第7次后為P4 //PeopleEnumerable2 （加上yield break） 迭代器生成后Current為空 迭代第0次后為P0 迭代第1次后為P1 迭代第2次后為P2 迭代第3次后為P3 迭代第4次后為P4 迭代第5次后為P4 迭代第6次后為P4 迭代第7次后為P4
真讓人吃驚，返回原始集合，越界之后就返回null了，但如果是MoveNext，不論有沒有加yield break, 越界迭代后還是返回最后一個元素！ 為什么會這樣呢？這個過程中發生了什么？ 也許就是我們在第1節里提到的，迭代器只返回上一次的狀態，因為無法后移，所以就重復返回，那為什么List集合就不會這樣呢？問題留給大家。
不過各位看官盡管放心，在foreach的標准枚舉過程下，枚舉是肯定能枚舉完的，這就說明了MoveNext和foreach兩種在實現上的不同，顯然foreach更安全。同時還注意，不能在yield過程中實現try-catch代碼塊，為什么呢？因為yield模式組合了來自不同位置的代碼和邏輯，怎么可能靠編譯給每個引用的代碼塊加上try-catch？這太復雜了。
枚舉的特性在處理大數據的時候很有幫助，就是因為它的狀態性，一個超大的文件，我只要每次讀一部分，就可以順次的讀取下去，直到文件結束，由於不需要實例化集合，內存占用是很低的。對數據庫也是如此，每次讀取一部分，就能應對很多難以應付的情況。
3.在枚舉中修改枚舉器參數？
在枚舉過程中，集合是不能被修改的，比如在foreach循環中，如果插入或者刪除一個元素，肯定會報運行時異常。有經驗的程序員告訴 你，此時用for循環。但你想過沒有，for和foreach的本質區別是什么呢？
在MoveNext中，我突然改變了枚舉的參數，使得它的數據量變多或者變少了，又會發生什么？
注意第一個代碼段里：
public int OldAge = 31; public IEnumerable<People> OlderPeoples { get { foreach (People people in _people) { if (people.Age > OldAge) //內部變量控制着迭代的數量 yield return people; } yield break; } }
那么在訪問過程中，修改OldAge的值，會怎樣呢？
Console.WriteLine("不修改OldAge參數"); foreach (var olderPeople in peopleList.OlderPeoples) { Console.WriteLine(olderPeople); } Console.WriteLine("修改了OldAge參數"); i = 0; foreach (var olderPeople in peopleList.OlderPeoples) { Console.WriteLine(olderPeople); i++; if (i > 0) peopleList.OldAge = 33; //只枚舉一次后，修改OldAge 的值 }
測試結果是：
不修改OldAge參數 ID:2,NameP2,Age32 ID:3,NameP3,Age33 ID:4,NameP4,Age34 修改了OldAge參數 ID:2,NameP2,Age32 ID:4,NameP4,Age34
可以看到，在枚舉過程中修改了控制枚舉的值，能動態改變枚舉的行為。上面是在一個yield結構中改變變量的情況，我們再試試在迭代器和Lambda表達式的情況：
int age = 31; Console.WriteLine("在迭代中修改變量值"); i = 0; IEnumerable<People> e4 = peopleList.PeopleEnumerable1.Where(d => d.Age > age); IEnumerator<People> e5 = e4.GetEnumerator(); i = 0; while (e5.MoveNext()) { Console.WriteLine(e5.Current); i++; if (i > 0) age = 33; }
age = 31; Console.WriteLine("在Lambda表達式中修改變量值"); foreach (People b in e4) { Console.WriteLine(b); i++; if (i > 0) age = 33; }
得到結果是：
在迭代中修改變量值 ID:2,NameP2,Age32 ID:4,NameP4,Age34 在Lambda表達式中修改變量值 ID:2,NameP2,Age32 ID:4,NameP4,Age34
可以看出，外部修改變量能夠控制內部的迭代過程，動態改變了“集合的元素”。 這是一個好事，因為它的行為確實是對的；也是壞事：它帶來了陷阱，保存了一個枚舉的引用，在迭代過程中，修改了變量的值，上下文語境變化，可是如果還按之前的語境進行處理，顯然就會釀成大錯。這件事以后深入討論，比如ETL。 這里和閉包沒關系。
如果你把兩個集合A,B用Concat函數順次拼接起來，也就是A-B, 而且不實例化，那么在枚舉A的階段中，修改集合B的元素，會報錯么？ 為什么？
這個答案絕對出乎你的想象！如果你想知道，可以自己做個試驗（在我附件里也有這個例子）。留給大家討論。
4. 更多LINQ的討論
你可以在yield中插入任何代碼，這就是延遲（Lazy）的表現，只是需要執行的時候才執行。 我們不難想象Linq很多函數的實現方式，比較有意思的包括Concat,它將兩個集合連在了一起，就像下面這樣：
public static IEnumerable<T> Concat<T>(this IEnumerable<T> source, IEnumerable<T> source2) { foreach (var r in source) { yield return r; } foreach (var r in source2) { yield return r; } }
還有Select, Where都好實現，就不討論了。
Skip怎么實現的呢？ 它跳過了集合中的一部分元素，我猜是這樣的：
public static IEnumerable<T> Skip<T>(this IEnumerable<T> source, int count) { int t = 0; foreach (var r in source) { t++; if(t<=count) continue; yield return r; } }
那么，被跳過的元素，到底被訪問過沒有？它的代碼被執行了么？
Console.WriteLine("Skip的元素是否會被訪問到？"); IEnumerable<People> e6 = peopleList.PeopleEnumerable1.Select(d => { Console.WriteLine(d); return d; }).Skip(3); Console.WriteLine("只枚舉，什么都不做："); foreach (var r in e6){}
Console.WriteLine("轉換為實體集合，再次枚舉"); IEnumerable<People> e7 = e6.ToList(); foreach (var r in e7){}
測試結果如下：
只枚舉，什么都不做：
ID:0,NameP0,Age30
ID:1,NameP1,Age31
ID:2,NameP2,Age32
ID:3,NameP3,Age33
ID:4,NameP4,Age34
轉換為實體集合，再次枚舉
ID:0,NameP0,Age30
ID:1,NameP1,Age31
ID:2,NameP2,Age32
ID:3,NameP3,Age33
ID:4,NameP4,Age34
可以看出，Skip雖然是跳過，但還是會“訪問”元素的，因此會執行額外的操作，比如lambda表達式，這不論是枚舉器還是實體集合都是如此。這個角度說，要優化表達式，應當盡可能在linq中早的Skip和Take，以減少額外的副作用。
對一般的大數據枚舉下，Skip的意義並不大。但對於Linq to SQL的實現中，顯然Skip是做過額外優化的。我們是否也能優化Skip的實現，使得上層盡可能提升海量數據下的Skip性能呢？
5. 有關IEnumerable枚舉的更多問題
(1) 枚舉過程如何暫停？有暫停這一說么？ 如何取消？
(2) PLinq的實現原理是什么？它改變的到底是IEnumerable接口的哪種特性？是否產生了亂序枚舉？這種亂序枚舉到底是怎么實現？
(3) IEnumerable實現了鏈條結構，這是Linq的基礎，但這個鏈條的本質是什么？
(4) 因為IEnumerable代表了狀態和延遲，因此就不難理解很多異步操作的本質就是IEnumerable。我有一次面試時候，問到了異步的實質，你說異步的實質是什么？異步不是多線程！異步的精彩，本質上是代碼的重新組合，因為長時間的異步操作就是狀態機。。。比如CCR庫。此處不准備展開說，因為暫時超過了作者的知識儲備，下次再說。
(5) 你可以將一個IEnumerable賦值到另外一個枚舉上，那么兩個枚舉到底是不是一個東西呢？ 應該是一個，因為枚舉接口顯然是引用類型
(6) 如果用C語言來實現同樣的枚舉器，同樣酷炫的Linq,不靠編譯器能實現么？先不提Lambda的梗，我們用函數指針。
(7) IEnumerable寫MapReduce? Linq for MapReduce?
(8) 函數式編程，閉包和IEnumerable？
(9) IEnumerable如何Sort? 實例化為一個集合再排序么？如果是一個超大的虛擬集合,如何優化？
下一篇我們詳細討論這些內容。附件是整個測試代碼，如果你覺得有幫助，請幫忙點推薦，謝謝.
完整測試代碼。
我的相似的一篇博文：你可能不知道的陷阱：C#委托和事件的困惑
6.參考文獻：
CLR via C#
http://www.codeproject.com/Articles/34405/WPF-Data-Virtualization