IEnumerable枚舉器接口的重要性，說一萬句話都不過分。幾乎所有集合都實現(xiàn)了這個接口，Linq的核心也依賴于這個***的接口。C語言的for循環(huán)寫得心煩，foreach就順暢了很多。

我很喜歡這個接口，但在使用中也遇到不少的疑問，你是不是也有與我一樣的困惑：

(1) IEnumerable 與  IEnumerator到底有什么區(qū)別

(2) 枚舉能否越界訪問，越界訪問是什么后果？為什么在枚舉中不能改變集合的值？

(3) Linq的具體實現(xiàn)到底是怎樣的，比如Skip,它跳過了一些元素，那么這些元素被訪問到了么？

(4) IEnumerable 的本質(zhì)是什么？

(5) IEnumerable 枚舉中是否會形成閉包？多個枚舉過程會不會互相干擾？能否在枚舉中動態(tài)改變枚舉的元素？

....

如果感興趣，我們接著下面的內(nèi)容。

開始之前，我們的文章規(guī)定，枚舉就是IEnumerable，迭代就是IEnumerator，已經(jīng)被實例化（比如ToList()）就是集合。

我的相似的一篇博文：你可能不知道的陷阱：C#委托和事件的困惑

1.  IEnumerable 與  IEnumerator

IEnumerable只有一個抽象方法：GetEnumerator()，而IEnumerator又是一個迭代器，真正實現(xiàn)了訪問集合的功能。  IEnumerator只有一個Current屬性，MoveNext和Reset兩個方法。

有個小問題，只搞一個訪問器接口不就得了？為什么要兩個看起來很容易混淆的接口呢？一個叫枚舉器，另一個叫迭代器。因為

(1) 實現(xiàn)IEnumerator是個臟活累活，白白加了兩個方法一個屬性，而且這兩個方法其實并不好實現(xiàn)（后面會提到）。

(2) 它需要維護初始狀態(tài)，知道如何MoveNext ,如何結(jié)束，同時返回迭代的上一個狀態(tài)，這些并不容易。

(3)迭代顯然是非線程安全的，每次IEnumerable都會生成新的IEnumerator，從而形成多個互相不影響的迭代過程。在迭代過程中，不能修改迭代集合，否則不安全。

所以只要你實現(xiàn)了IEnumerable，編譯器就會幫我們實現(xiàn)IEnumerator。何況絕大多數(shù)情況都是從現(xiàn)有集合繼承，一般不需要重寫MoveNext和Reset方法。 IEnumerable當(dāng)然還有泛型實現(xiàn)，這個不影響問題的討論。

IEnumerable讓我們想起了單向鏈表，C中需要一個指針域保存下一個節(jié)點的信息，那么在IEnumerable中，誰幫忙保存了這個信息？這個過程占用內(nèi)存么？ 是占在程序區(qū)，還是堆區(qū)？

但是，IEnumerable也有它的缺點，它沒法后退，沒法跳躍（只能一個一個的跳過去），而且實現(xiàn)Reset并不容易,無法實現(xiàn)索引訪問。想想看， 如果是一個實例集合的枚舉過程，直接返回到第0個元素就可以了，但是如果這個IEnumerable是漫長的訪問鏈條，想找到最初的根是很困難的！所 以CLR via C#的作者告訴你，其實很多Reset的實現(xiàn)根本就是謊言，知道有這個東西就行了，不要太過依賴它。

2. foreach和MoveNext有區(qū)別嗎

IEnumerable***的特點是將訪問的過程，交給了被訪問者本身控制。在C語言中數(shù)組控制權(quán)是外部完全掌握的。這個接口卻在內(nèi)部封裝訪問了的過程，進一步提升了封裝性。比如下面

public class People  //定義一個簡單的實體類 
    { 
        public string Name { get; set; } 
        public int Age { get; set; } 
    } 
 
    public class PersonList 
    { 
        private readonly List<People> peoples; 
 
        public PersonList()  //為了方便，構(gòu)造過程中插入元素 
        { 
            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的本質(zhì)是狀態(tài)機，它有點類似事件的概念，將實現(xiàn)丟到外面，實現(xiàn)代碼間的穿越（想想星際穿越），這是Linq的基礎(chǔ)。酷炫的迭代器，真的有我們想象的那么簡單么？

在C語言中，數(shù)組就是數(shù)組，實實在在的內(nèi)存空間，那么IEnumerable到底是什么意思呢？如果它由一個真正的集合（比如List）實現(xiàn)，那么沒問題，也是實實在在的內(nèi)存，可是如果是上述的例子呢？篩選返回的yield return 只返回了元素，但可能并不存在這個實際的集合，如果你將簡單的枚舉器的yield return 反編譯后看，會發(fā)現(xiàn)其實是一組switch-case, 編譯器在后臺為我們做了大量的工作。

生成的新迭代器，如果不MoveNext，其實Current是空的，這是為什么呢？為什么一個迭代器不直接指向頭元素呢？

（感謝回答：就像C語言的單向鏈表的頭指針一樣，這樣可以指定一個不包含任何元素的枚舉，程序設(shè)計起來更方便）

foreach每次往前移動一格，到頭了就停止。 等等，你確定它到頭了就會停止么？我們來做個試驗：

public IEnumerable<People> Peoples1   //直接返回集合 
        { 
            get { return peoples; } 
        }public IEnumerable<People> Peoples2  //包含yield break; 
        { 
            get 
            { 
                foreach (var people in peoples) 
                { 
                    yield return people; 
                } 
                yield break;  //其實這個用不用都可以 
            } 
        } 

以上兩種，是我們常見的方式，注意第二種實現(xiàn)，ReSharper把yield break標(biāo)成灰色（重復(fù)）。

我們再寫下如下的測試代碼，peopleList集合只有五個元素，但嘗試去MoveNext 8次。可以把peopleList.Peoples1換成2,3，分別測試。

var peopleList = new PeopleList();  //內(nèi)部構(gòu)造函數(shù)插入了五個元素 
            IEnumerator<People> e1 = peopleList.Peoples1.GetEnumerator(); 
            if (e1.Current == null) 
            { 
                Console.WriteLine("迭代器生成后Current為空"); 
            } 
            int i = 0; 
            while (i<8)  //總共只有五個元素，看看一直迭代會發(fā)生什么效果 
            { 
                e1.MoveNext(); 
                if (e1.Current == null) 
                { 
                    Console.WriteLine("迭代第{0}次后為空",i); 
                } 
                else 
                { 
                    Console.WriteLine("迭代第{0}次后為{1}",i,e1.Current.Name); 
                } 
                i++; 
            } 

越界枚舉測試結(jié)果

//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 
 
越界枚舉測試結(jié)果 

真讓人吃驚，返回原始集合，越界之后就返回null了，但如果是MoveNext，不論有沒有加yield break, 越界迭代后還是返回***一個元素！ 也許就是我們在第1節(jié)里提到的，迭代器只返回上一次的狀態(tài)，因為無法后移，所以就重復(fù)返回，那為什么List集合就不會這樣呢？問題留給大家。

（感謝回答：越界枚舉到底是null還是***一個元素的問題，其實沒有明確規(guī)定，具體看.NET的實現(xiàn)，在.NET Framework中，越界后依然是***一個元素）。

不過各位看官盡管放心，在foreach的標(biāo)準(zhǔn)枚舉過程下，枚舉是肯定能枚舉完的，這就說明了MoveNext和foreach兩種在實現(xiàn)上的不同，顯然foreach更安全。同時還注意，不能在yield過程中實現(xiàn)try-catch代碼塊，為什么呢？因為yield模式組合了來自不同位置的代碼和邏輯，怎么可能靠編譯給每個引用的代碼塊加上try-catch？這太復(fù)雜了。

枚舉的特性在處理大數(shù)據(jù)的時候很有幫助，就是因為它的狀態(tài)性，一個超大的文件，我只要每次讀一部分，就可以順次的讀取下去，直到文件結(jié)束，由于不需要實例化集合，內(nèi)存占用是很低的。對數(shù)據(jù)庫也是如此，每次讀取一部分，就能應(yīng)對很多難以應(yīng)付的情況。

3.在枚舉中修改枚舉器參數(shù)？

在枚舉過程中，集合是不能被修改的，比如在foreach循環(huán)中，如果插入或者刪除一個元素，肯定會報運行時異常。有經(jīng)驗的程序員告訴 你，此時用for循環(huán)。for和foreach的本質(zhì)區(qū)別是什么呢？ 

在MoveNext中，我突然改變了枚舉的參數(shù)，使得它的數(shù)據(jù)量變多或者變少了，又會發(fā)生什么？

Console.WriteLine("不修改OldAge參數(shù)"); 
            foreach (var olderPeople in peopleList.OlderPeoples) 
            { 
                Console.WriteLine(olderPeople); 
               
            } 
 
            Console.WriteLine("修改了OldAge參數(shù)"); 
            i = 0; 
            foreach (var olderPeople in peopleList.OlderPeoples) 
            { 
                Console.WriteLine(olderPeople); 
                i++; 
                if (i ==1) 
                    peopleList.OldAge = 33;  //只枚舉一次后，修改OldAge 的值 
            } 

測試結(jié)果是：

不修改OldAge參數(shù) 
ID:2,NameP2,Age32 
ID:3,NameP3,Age33 
ID:4,NameP4,Age34 
 
修改了OldAge參數(shù) 
ID:2,NameP2,Age32 
ID:4,NameP4,Age34 

可以看到，在枚舉過程中修改了控制枚舉的值，能動態(tài)改變枚舉的行為。上面是在一個yield結(jié)構(gòu)中改變變量的情況，我們再試試在迭代器和Lambda表達式的情況（代碼略）， 得到結(jié)果是：

在迭代中修改變量值 
ID:2,NameP2,Age32 
ID:4,NameP4,Age34 
在Lambda表達式中修改變量值 
ID:2,NameP2,Age32 
ID:4,NameP4,Age34 

可以看出，外部修改變量能夠控制內(nèi)部的迭代過程，動態(tài)改變了“集合的元素”。 這是一個好事，因為它的行為確實是對的；也是壞事：在迭代過程中，修改了變量的值，上下文語境變化，可是如果還按之前的語境進行處理，顯然就會釀成大錯。 這里和閉包沒關(guān)系。

因此，如果一個枚舉需要在上下文會發(fā)生變化的情況下保持原有的行為，就需要手動保存變量的副本。

如果你把兩個集合A,B用Concat函數(shù)順次拼接起來，也就是A-B, 而且不實例化，那么在枚舉A的階段中，修改集合B的元素，會報錯么？ 為什么？

比如如下的測試代碼：

List<People> peoples=new List<People>(){new People(){Name = "PA"}}; 
            Console.WriteLine("將一個虛擬枚舉A連接到集合B，并在枚舉A階段修改集合B的元素"); 
            var e8 = peopleList.PeopleEnumerable1.Concat(peoples); 
            i = 0; 
            foreach (var people in e8) 
            { 
                Console.WriteLine(people); 
                i++; 
                if (i == 1)    
                  peoples.Add(new People(){Name = "PB"});  //此時還在枚舉PeopleEnumerable1階段 
　　　　　　　　} 

如果你想知道，可以自己做個試驗（在我附件里也有這個例子）。留給大家討論。

4. 更多LINQ的討論

你可以在yield中插入任何代碼，這就是延遲（Lazy）的表現(xiàn)，只是需要執(zhí)行的時候才執(zhí)行。 我們不難想象Linq很多函數(shù)的實現(xiàn)方式，比較有意思的包括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都好實現(xiàn)，就不討論了。

Skip怎么實現(xiàn)的呢？  它跳過了集合中的一部分元素，我猜是這樣的：

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; 
           } 
       } 

那么，被跳過的元素，到底被訪問過沒有？它的代碼被執(zhí)行了么？

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("轉(zhuǎn)換為實體集合，再次枚舉"); 
 IEnumerable<People> e7 = e6.ToList(); 
 foreach (var r in e7){} 

測試結(jié)果如下：

只枚舉，什么都不做： 
ID:0,NameP0,Age30 
ID:1,NameP1,Age31 
ID:2,NameP2,Age32 
ID:3,NameP3,Age33 
ID:4,NameP4,Age34 
轉(zhuǎn)換為實體集合，再次枚舉 
ID:0,NameP0,Age30 
ID:1,NameP1,Age31 
ID:2,NameP2,Age32 
ID:3,NameP3,Age33 
ID:4,NameP4,Age34 

可以看出，Skip雖然是跳過，但還是會“訪問”元素的，因此會執(zhí)行額外的操作，比如lambda表達式，這不論是枚舉器還是實體集合都是如此。這個角度說，要優(yōu)化表達式，應(yīng)當(dāng)盡可能在linq中早的Skip和Take，以減少額外的副作用。

但對于Linq to SQL的實現(xiàn)中，顯然Skip是做過額外優(yōu)化的。我們是否也能優(yōu)化Skip的實現(xiàn)，使得上層盡可能提升海量數(shù)據(jù)下的Skip性能呢？

5. 有關(guān)IEnumerable枚舉的更多問題

(1) 枚舉過程如何暫停？有暫停這一說么？ 如何取消？

(2) PLinq的實現(xiàn)原理是什么？它改變的到底是IEnumerable接口的哪種特性？是否產(chǎn)生了亂序枚舉？這種亂序枚舉到底是怎么實現(xiàn)？

(3) IEnumerable實現(xiàn)了鏈條結(jié)構(gòu)，這是Linq的基礎(chǔ)，但這個鏈條的本質(zhì)是什么？

(4) 因為IEnumerable代表了狀態(tài)和延遲，因此就不難理解很多異步操作的本質(zhì)就是IEnumerable。我有一次面試時候，問到了異步的實質(zhì)，你說異步的實質(zhì)是什么？異步不是多線程！異步的精彩，本質(zhì)上是代碼的重新組合，因為長時間的異步操作就是狀態(tài)機。。。比如CCR庫。此處不準(zhǔn)備展開說，因為暫時超過了作者的知識儲備，下次再說。

(5) 如果用C語言來實現(xiàn)同樣的枚舉器，同樣酷炫的Linq,不靠編譯器能實現(xiàn)么？先不提Lambda的梗，我們用函數(shù)指針。

(6) IEnumerable寫MapReduce? Linq for MapReduce?

(7) IEnumerable如何Sort? 實例化為一個集合再排序么？如果是一個超大的虛擬集合,如何優(yōu)化？

下一篇我們詳細討論這些內(nèi)容。附件是整個測試代碼，如果你覺得有幫助，請幫忙點推薦，謝謝.

完整測試代碼。