C#你可能不知道的陷阱, IEnumerable介面

IEnumerable列舉器介面的重要性，說一萬句話都不過分。幾乎所有集合都實現了這個介面，Linq的核心也依賴於這個萬能的介面。C語言的for迴圈寫得心煩，foreach就順暢了很多。

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

(1) IEnumerable 與  IEnumerator到底有什麼區別

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

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

(4) IEnumerable 的本質是什麼？

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

….

如果感興趣，我們接著下面的內容。

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

1.  IEnumerable 與  IEnumerator

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

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

(1) 實現IEnumerator是個髒活累活，白白加了兩個方法一個屬性，而且這兩個方法其實並不好實現（後面會提到）。

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

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

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

IEnumerable讓我們想起了單向連結串列，C中需要一個指標域儲存下一個節點的資訊，那麼在IEnumerable中，誰幫忙儲存了這個資訊？這個過程佔用記憶體麼？ 是佔在程式區，還是堆區？

但是，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是空的，這是為什麼呢？為什麼一個迭代器不直接指向頭元素呢？

（感謝回答：就像C語言的單向連結串列的頭指標一樣，這樣可以指定一個不包含任何元素的列舉，程式設計起來更方便）

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;  //其實這個用不用都可以
            }
        }

以上兩種，是我們常見的方式，注意第二種實現，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集合就不會這樣呢？問題留給大家。

（感謝回答：越界列舉到底是null還是最後一個元素的問題，其實沒有明確規定，具體看.NET的實現，在.NET Framework中，越界後依然是最後一個元素）。

不過各位看官儘管放心，在foreach的標準列舉過程下，列舉是肯定能列舉完的，這就說明了MoveNext和foreach兩種在實現上的不同，顯然foreach更安全。同時還注意，不能在yield過程中實現try-catch程式碼塊，為什麼呢？因為yield模式組合了來自不同位置的程式碼和邏輯，怎麼可能靠編譯給每個引用的程式碼塊加上try-catch？這太複雜了。

列舉的特性在處理大資料的時候很有幫助，就是因為它的狀態性，一個超大的檔案，我只要每次讀一部分，就可以順次的讀取下去，直到檔案結束，由於不需要例項化集合，記憶體佔用是很低的。對資料庫也是如此，每次讀取一部分，就能應對很多難以應付的情況。

3.在列舉中修改列舉器引數？

在列舉過程中，集合是不能被修改的，比如在foreach迴圈中，如果插入或者刪除一個元素，肯定會報執行時異常。有經驗的程式設計師告訴 你，此時用for迴圈。for和foreach的本質區別是什麼呢？

在MoveNext中，我突然改變了列舉的引數，使得它的資料量變多或者變少了，又會發生什麼？

           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 ==1)
                    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表示式的情況（程式碼略）， 得到結果是：

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

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

因此，如果一個列舉需要在上下文會發生變化的情況下保持原有的行為，就需要手動儲存變數的副本。

如果你把兩個集合A,B用Concat函式順次拼接起來，也就是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）的表現，只是需要執行的時候才執行。 我們不難想象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，以減少額外的副作用。

但對於Linq to SQL的實現中，顯然Skip是做過額外優化的。我們是否也能優化Skip的實現，使得上層儘可能提升海量資料下的Skip效能呢？

5. 有關IEnumerable列舉的更多問題

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

(2) PLinq的實現原理是什麼？它改變的到底是IEnumerable介面的哪種特性？是否產生了亂序列舉？這種亂序列舉到底是怎麼實現？

(3) IEnumerable實現了鏈條結構，這是Linq的基礎，但這個鏈條的本質是什麼？

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

(5) 如果用C語言來實現同樣的列舉器，同樣酷炫的Linq,不靠編譯器能實現麼？先不提Lambda的梗，我們用函式指標。

(6) IEnumerable寫MapReduce? Linq for MapReduce?

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