詳解C# 迭代器

    迭代器模式是設計模式中行爲模式(behavioral pattern)的一個例子，他是一種簡化對象間通信的模式，也是一種很是容易理解和使用的模式。簡單來講，迭代器模式使得你可以獲取到序列中的全部元素而不用關心是其類型是array，list，linked list或者是其餘什麼序列結構。這一點使得可以很是高效的構建數據處理通道(data pipeline)--即數據可以進入處理通道，進行一系列的變換，或者過濾，而後獲得結果。事實上，這正是LINQ的核心模式。

    在.NET中，迭代器模式被IEnumerator和IEnumerable及其對應的泛型接口所封裝。若是一個類實現了IEnumerable接口，那麼就可以被迭代；調用GetEnumerator方法將返回IEnumerator接口的實現，它就是迭代器自己。迭代器相似數據庫中的遊標，他是數據序列中的一個位置記錄。迭代器只能向前移動，同一數據序列中能夠有多個迭代器同時對數據進行操做。

    在C#1中已經內建了對迭代器的支持，那就是foreach語句。使得可以進行比for循環語句更直接和簡單的對集合的迭代，編譯器會將foreach編譯來調用GetEnumerator和MoveNext方法以及Current屬性，若是對象實現了IDisposable接口，在迭代完成以後會釋放迭代器。可是在C#1中，實現一個迭代器是相對來講有點繁瑣的操做。C#2使得這一工做變得大爲簡單，節省了實現迭代器的很多工做。

接下來，咱們來看如何實現一個迭代器以及C#2對於迭代器實現的簡化，而後再列舉幾個迭代器在現實生活中的例子。

 

1. C#1:手動實現迭代器的繁瑣

 

    假設咱們須要實現一個基於環形緩衝的新的集合類型。咱們將實現IEnumerable接口，使得用戶可以很容易的利用該集合中的全部元素。咱們的忽略其餘細節，將注意力僅僅集中在如何實現迭代器上。集合將值存儲在數組中，集合可以設置迭代的起始點，例如，假設集合有5個元素，你可以將起始點設爲2，那麼迭代輸出爲2，3，4，0，最後是1.

    爲了可以簡單展現，咱們提供了一個設置值和起始點的構造函數。使得咱們可以如下面這種方式遍歷集合：

object[] values = { "a", "b", "c", "d", "e" };
IterationSample collection = new IterationSample(values, 3);
foreach (object x in collection)
{
    Console.WriteLine(x);
}

因爲咱們將起始點設置爲3，因此集合輸出的結果是d,e,a,b及c，如今，咱們來看如何實現 IterationSample 類的迭代器：

class IterationSample : IEnumerable
{
    Object[] values;
    Int32 startingPoint;
    public IterationSample(Object[] values, Int32 startingPoint)
    {
        this.values = values;
        this.startingPoint = startingPoint;
    }
    public IEnumerator GetEnumerator()
    {
        throw new NotImplementedException();
    }
}

    咱們尚未實現GetEnumerator方法，可是如何寫GetEnumerator部分的邏輯呢，第一就是要將遊標的當前狀態存在某一個地方。一方面是迭代器模式並非一次返回全部的數據，而是客戶端一次只請求一個數據。這就意味着咱們要記錄客戶當前請求到了集合中的那一個記錄。C#2編譯器對於迭代器的狀態保存爲咱們作了不少工做。

       如今來看看，要保存哪些狀態以及狀態存在哪一個地方，設想咱們試圖將狀態保存在IterationSample集合中，使得它實現IEnumerator和IEnumerable方法。咋一看，看起來可能，畢竟數據在正確的地方，包括起始位置。咱們的GetEnumerator方法僅僅返回this。可是這種方法有一個很重要的問題，若是GetEnumerator方法調用屢次，那麼多個獨立的迭代器就會返回。例如，咱們可使用兩個嵌套的foreach語句，來獲取全部可能的值對。這兩個迭代須要彼此獨立。這意味着咱們須要每次調用GetEnumerator時返回的兩個迭代器對象必須保持獨立。咱們仍舊能夠直接在IterationSample類中經過相應函數實現。可是咱們的類擁有了多個職責，這位背了單一職責原則。

     所以，咱們來建立另一個類來實現迭代器自己。咱們使用C#中的內部類來實現這一邏輯。代碼以下：

class IterationSampleEnumerator : IEnumerator
{
    IterationSample parent;//迭代的對象  #1
    Int32 position;//當前遊標的位置 #2
    internal IterationSampleEnumerator(IterationSample parent)
    {
        this.parent = parent;
        position = -1;// 數組元素下標從0開始，初始時默認當前遊標設置爲 -1，即在第一個元素以前， #3
    }

    public bool MoveNext()
    {
        if (position != parent.values.Length) //判斷當前位置是否爲最後一個，若是不是遊標自增 #4
        {
            position++;
        }
        return position < parent.values.Length;
    }

    public object Current
    {
        get
        {
            if (position == -1 || position == parent.values.Length)//第一個以前和最後一個自後的訪問非法 #5
            {
                throw new InvalidOperationException();
            }
            Int32 index = position + parent.startingPoint;//考慮自定義開始位置的狀況  #6
            index = index % parent.values.Length;
            return parent.values[index];
        }
    }

    public void Reset()
    {
        position = -1;//將遊標重置爲-1  #7
    }
}

要實現一個簡單的迭代器須要手動寫這麼多的代碼：須要記錄迭代的原始集合#1，記錄當前遊標位置#2，返回元素時，根據當前遊標和數組定義的起始位置設置定迭代器在數組中的位置#6。初始化時，將當前位置設定在第一個元素以前#3，當第一次調用迭代器時首先須要調用MoveNext，而後再調用Current屬性。在遊標自增時對當前位置進行條件判斷#4，使得即便當第一次調用MoveNext時沒有可返回的元素也不至於出錯#5。重置迭代器時，咱們將當前遊標的位置還原到第一個元素以前#7。

    除告終合當前遊標位置和自定義的起始位置返回正確的值這點容易出錯外，上面的代碼很是直觀。如今，只須要在IterationSample類的GetEnumerator方法中返回咱們當才編寫的迭代類便可：

public IEnumerator GetEnumerator()
{
    return new IterationSampleEnumerator(this);
}

    值得注意的是，上面只是一個相對簡單的例子，沒有太多的狀態須要跟蹤，不用檢查集合在迭代的過程當中是否發生了變化。爲了實現一個簡單的迭代器，在C#1中咱們實現瞭如此多的代碼。在使用Framework自帶的實現了IEnumerable接口的集合時咱們使用foreach很方便，可是當咱們書寫本身的集合來實現迭代時須要編寫這麼多的代碼。

    在C#1中，大概須要40行代碼來實現一個簡單的迭代器，如今看看C#2對這一過程的改進。

 

2. C#2:經過yield語句簡化迭代

 

2.1 引入迭代塊(iterator)和yield return 語句

C#2使得迭代變得更加簡單--減小了不少代碼量也使得代碼更加的優雅。下面的代碼展現了再C#2中實現GetEnumerator方法的完整代碼：

public IEnumerator GetEnumerator()
{
    for (int index = 0; index < this.values.Length; index++)
    {
        yield return values[(index + startingPoint) % values.Length];
    }
}

簡單幾行代碼就可以徹底實現IterationSampleIterator類所須要的功能。方法看起來很普通，除了使用了yield return。這條語句告訴編譯器這不是一個普通的方法，而是一個須要執行的迭代塊（yield block），他返回一個IEnumerator對象，你可以使用迭代塊來執行迭代方法並返回一個IEnumerable須要實現的類型，IEnumerator或者對應的泛型。若是實現的是非泛型版本的接口，迭代塊返的yield type是Object類型，不然返回的是相應的泛型類型。例如，若是方法實現IEnumerable<String>接口，那麼yield返回的類型就是String類型。 在迭代塊中除了yield return外，不容許出現普通的return語句。塊中的全部yield return 語句必須返回和塊的最後返回類型兼容的類型。舉個例子，若是方法定義須要返回IEnumeratble<String>類型的話，不能yield return 1 。 須要強調的一點是，對於迭代塊，雖然咱們寫的方法看起來像是在順序執行，實際上咱們是讓編譯器來爲咱們建立了一個狀態機。這就是在C#1中咱們書寫的那部分代碼---調用者每次調用只須要返回一個值，所以咱們須要記住最後一次返回值時，在集合中位置。 當編譯器遇到迭代塊是，它建立了一個實現了狀態機的內部類。這個類記住了咱們迭代器的準確當前位置以及本地變量，包括參數。這個類有點相似與咱們以前手寫的那段代碼，他將全部須要記錄的狀態保存爲實例變量。下面來看看，爲了實現一個迭代器，這個狀態機須要按順序執行的操做：

• 它須要一些初始的狀態
• 當MoveNext被調用時，他須要執行GetEnumerator方法中的代碼來準備下一個待返回的數據。
• 當調用Current屬性是，須要返回yielded的值。
• 須要知道何時迭代結束是，MoveNext會返回false

下面來看看迭代器的執行順序。

 

2.2 迭代器的執行流程

以下的代碼，展現了迭代器的執行流程，代碼輸出(0,1,2,-1)而後終止。

class Program
{
    static readonly String Padding = new String(' ', 30);
    static IEnumerable<Int32> CreateEnumerable()
    {
        Console.WriteLine("{0} CreateEnumerable()方法開始", Padding);
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("{0}開始 yield {1}", i);
            yield return i;
            Console.WriteLine("{0}yield 結束", Padding);
        }
        Console.WriteLine("{0} Yielding最後一個值", Padding);
        yield return -1;
        Console.WriteLine("{0} CreateEnumerable()方法結束", Padding);
    }

    static void Main(string[] args)
    {
        IEnumerable<Int32> iterable = CreateEnumerable();
        IEnumerator<Int32> iterator = iterable.GetEnumerator();
        Console.WriteLine("開始迭代");
        while (true)
        {
            Console.WriteLine("調用MoveNext方法……");
            Boolean result = iterator.MoveNext();
            Console.WriteLine("MoveNext方法返回的{0}", result);
            if (!result)
            {
                break;
            }
            Console.WriteLine("獲取當前值……");
            Console.WriteLine("獲取到的當前值爲{0}", iterator.Current);
        }
        Console.ReadKey();
    }
}

爲了展現迭代的細節，以上代碼使用了while循環，正常狀況下通常使用foreach。和上次不一樣，此次在迭代方法中咱們返回的是IEnumerable;對象而不是IEnumerator;對象。一般，爲了實現IEnumerable接口，只須要返回IEnumerator對象便可；若是自是想從一個方法中返回一些列的數據，那麼使用IEnumerable.如下是輸出結果：

 

從輸出結果中能夠看出一下幾點：

• 直到第一次調用MoveNext，CreateEnumerable中的方法才被調用。
• 在調用MoveNext的時候，已經作好了全部操做，返回Current屬性並無執行任何代碼。
• 代碼在yield return以後就中止執行，等待下一次調用MoveNext方法的時候繼續執行。
• 在方法中能夠有多個yield return語句。
• 在最後一個yield return執行完成後，代碼並無終止。調用MoveNext返回false使得方法結束。

    第一點尤其重要：這意味着，不能在迭代塊中寫任何在方法調用時須要當即執行的代碼--好比說參數驗證。若是將參數驗證放在迭代塊中，那麼他將不可以很好的起做用，這是常常會致使的錯誤的地方，並且這種錯誤不容易發現。

    下面來看如何中止迭代，以及finally語句塊的特殊執行方式。

 

2.3 迭代器的特殊執行流程

    在普通的方法中，return語句一般有兩種做用，一是返回調用者執行的結果。二是終止方法的執行，在終止以前執行finally語句中的方法。在上面的例子中，咱們看到了yield return語句只是短暫的退出了方法，在MoveNext再次調用的時候繼續執行。在這裏咱們沒有寫finally語句塊。如何真正的退出方法，退出方法時finnally語句塊如何執行，下面來看看一個比較簡單的結構：yield break語句塊。

使用 yield break 結束一個迭代

    一般咱們要作的是使方法只有一個退出點，一般，多個退出點的程序會使得代碼不易閱讀，特別是使用try catch finally等語句塊進行資源清理以及異常處理的時候。在使用迭代塊的時候也會遇到這樣的問題，但若是你想早點退出迭代，那麼使用yield break就能達到想要的效果。他可以立刻終止迭代，使得下一次調用MoveNext的時候返回false。

下面的代碼演示了從1迭代到100，可是時間超時的時候就中止了迭代。

static IEnumerable<Int32> CountWithTimeLimit(DateTime limit)
{
    try
    {
        for (int i = 1; i <= 100; i++)
        {
            if (DateTime.Now >= limit)
            {
                yield break;
            }
            yield return i;
        }
    }
    finally
    {
        Console.WriteLine("中止迭代！"); Console.ReadKey();
    }
}
static void Main(string[] args)
{
    DateTime stop = DateTime.Now.AddSeconds(2);
    foreach (Int32 i in CountWithTimeLimit(stop))
    {
        Console.WriteLine("返回 {0}", i);
        Thread.Sleep(300);
    }
}

下圖是輸出結果，能夠看出迭代語句正常終止，yield return語句和普通方法中的return語句同樣，下面來看看finally語句塊是何時以及如何執行的。

 

Finally語句塊的執行

    一般，finally語句塊在當方法執行退出特定區域時就會執行。迭代塊中的finally語句和普通方法中的finally語句塊不同。就像咱們看到的，yield return語句中止了方法的執行，而不是退出方法，根據這一邏輯，在這種狀況下，finally語句塊中的語句不會執行。

    但當碰到yield break語句的時候，就會執行finally 語句塊，這根普通方法中的return同樣。通常在迭代塊中使用finally語句來釋放資源，就像使用using語句同樣。

    下面來看finally語句如何執行。

   無論是迭代到了100次或者是因爲時間到了中止了迭代，或者是拋出了異常，finally語句總會執行，可是在有些狀況下，咱們不想讓finally語句塊被執行。

    只有在調用MoveNext後迭代塊中的語句纔會執行，那麼若是不掉用MoveNext呢，若是調用幾回MoveNext而後中止調用，結果會怎麼樣呢？請看下面的代碼？

DateTime stop = DateTime.Now.AddSeconds(2);
foreach (Int32 i in CountWithTimeLimit(stop))
{
    if (i > 3)
    {
        Console.WriteLine("返回中^");
        return;
    }
    Thread.Sleep(300);
}

   在forech中，return語句以後，由於CountWithTimeLimit中有finally塊因此代碼繼續執行CountWithTimeLimit中的finally語句塊。foreach語句會調用GetEnumerator返回的迭代器的Dispose方法。在結束迭代以前調用包含迭代塊的迭代器的Dispose方法時，狀態機會執行在迭代器範圍內處於暫停狀態下的代碼範圍內的全部finally塊，這有點複雜，可是結果很容易解釋：只有使用foreach調用迭代，迭代塊中的finally塊會如指望的那樣執行。下面能夠用代碼驗證以上結論：

IEnumerable<Int32> iterable = CountWithTimeLimit(stop);
IEnumerator<Int32> iterator = iterable.GetEnumerator();

iterator.MoveNext();
Console.WriteLine("返回 {0}", iterator.Current);

iterator.MoveNext();
Console.WriteLine("返回 {0}", iterator.Current);
Console.ReadKey();

代碼輸出以下：

上圖能夠看出，中止迭代沒有打印出來，當咱們手動調用iterator的Dispose方法時，會看到以下的結果。在迭代器迭代結束前終止迭代器的狀況不多見，也不多不使用foreach語句而是手動來實現迭代，若是要手動實現迭代，別忘了在迭代器外面使用using語句，以確保可以執行迭代器的Dispose方法進而執行finally語句塊。 

下面來看看微軟對迭代器的一些實現中的特殊行爲：

 

2.4 迭代器執行中的特殊行爲

 

    若是使用C#2的編譯器將迭代塊編譯，而後使用ildsam或者Reflector查看生成的IL代碼，你會發如今幕後編譯器回味咱們生成了一些嵌套的類型(nested type).下圖是使用Ildsam來查看生成的IL ,最下面兩行是代碼中的的兩個靜態方法，上面藍色的<CountWithTimeLimit>d_0是編譯器爲咱們生成的類(尖括號只是類名，和泛型無關)，代碼中能夠看出該類實現了那些接口，以及有哪些方法和字段。大概和咱們手動實現的迭代器結構相似。

真正的代碼邏輯實在MoveNext方法中執行的，其中有一個大的switch語句。幸運的是，做爲一名開發人員不必瞭解這些細節，但一些迭代器執行的方式仍是值得注意的：

• 在MoveNext方法第一次執行以前，Current屬性老是返回迭代器返回類型的默認的值。例如IEnumeratble返回的是Int32類型，那麼默認初始值是0，因此在調用MoveNext方法以前調用Current屬性就會返回0。
• MoveNext方法返回false後，Current屬性老是返回最後迭代的那個值。
• Reset方法通常會拋出異常，而在本文開始代碼中，咱們手動實現一個迭代器時在Reset中可以正確執行邏輯。
• 編譯器爲咱們產生的嵌套類會同時實現IEnumerator的泛型和非泛型版本(恰當的時候還會實現IEnumerable的泛型和非泛型版本).

   沒有正確實現Reset方法是有緣由的--編譯器不知道須要使用怎樣的邏輯來重新設置迭代器。不少人認爲不該該有Reset方法，不少集合並不支持，所以調用者不該該依賴這一方法。

   實現其它接口沒有壞處。方法中返回IEnumerable接口，他實現了五個接口(包括IDisposable)，做爲一個開發者不用擔憂這些。同時實現IEnumerable和IEnumerator接口並不常見，編譯器爲了使迭代器的行爲老是正常，而且爲可以在當前的線程中僅僅須要迭代一個集合就能建立一個單獨的嵌套類型才這麼作的。

   Current屬性的行爲有些古怪，他保存了迭代器的最後一個返回值而且阻止了垃圾回收期進行收集。

所以，自動實現的迭代器方法有一些小的缺陷，可是明智的開發者不會遇到任何問題，使用他可以節省不少代碼量，使得迭代器的使用程度比C#1中要廣。下面來看在實際開發中迭代器簡化代碼的地方。

 

 

3.實際開發中使用迭代的例子

 

3.1 從時間段中迭代日期

在涉及到時間區段時，一般會使用循環，代碼以下：

for (DateTime day = timetable.StartDate; day < timetable.EndDate; day=day.AddDays(1))
{
    ……
}

循環有時沒有迭代直觀和有表現力，在本例中，能夠理解爲「時間區間中的每一天」，這正是foreach使用的場景。所以上述循環若是寫成迭代，代碼會更美觀：

foreach(DateTime day in timetable.DateRange)
{
    ……
}

在C#1.0中要實現這個須要下必定功夫。到了C#2.0就變得簡單了。在timetable類中，只須要添加一個屬性：

public IEnumerable<DateTime> DateRange
{
    get
    {
        for (DateTime day=StartDate ; day < =EndDate; day=day.AddDays(1))
        {
            yield return day;
        }
    } 
}

   只是將循環移動到了timetable類的內部，可是通過這一改動，使得封裝變得更爲良好。DateRange屬性只是遍歷時間區間中的每一天，每一次返回一天。若是想要使得邏輯變得複雜一點，只須要改動一處。這一小小的改動使得代碼的可讀性大大加強，接下來能夠考慮將這個Range擴展爲泛型Range<T>。

 

3.2迭代讀取文件中的每一行

 

讀取文件時，咱們常常會書寫這樣的代碼：

using (TextReader reader=File.OpenText(fileName))
{
    String line;
    while((line=reader.ReadLine())!=null)
    {
       ……
    }
}

 

這一過程當中有4個環節：

• 如何獲取TextReader
• 管理TextReader的生命週期
• 經過TextReader.ReadLine迭代全部的行
• 對行進行處理

能夠從兩個方面對這一過程進行改進:可使用委託--能夠寫一個擁有reader和一個代理做爲參數的輔助方法，使用代理方法來處理每一行，最後關閉reader，這常常被用來展現閉包和代理。還有一種更爲優雅更符合LINQ方式的改進。除了將邏輯做爲方法參數傳進去，咱們可使用迭代來迭代一次迭代一行代碼，這樣咱們就可使用foreach語句。代碼以下：

static IEnumerable<String> ReadLines(String fileName)
{
    using (TextReader reader = File.OpenText(fileName))
    {
        String line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

這樣就可使用以下foreach方法來讀取文件了：

foreach (String line in ReadLines("test.txt"))
{
    Console.WriteLine(line);
}

   方法的主體部分和以前的同樣，使用yield return返回了讀取到的每一行，只是在迭代結束後有點不一樣。以前的操做，先打開文檔，每一次讀取一行，而後在讀取結束時關閉reader。雖然」當讀取結束時」和以前方法中使用using類似，但當使用迭代時這個過程更加明顯。

這就是爲何foreach迭代結束後會調用迭代器的dispose方法這麼重要的緣由了，這個操做可以保證reader可以獲得釋放。迭代方法中的using語句塊相似與try/finally語句塊；finally語句在讀取文件結束或者當咱們顯示調用IEnumerator<String> 的Dispose方法時都會執行。可能有時候會經過ReadLine().GetEnumerator()的方式返回IEnumerator<String> ，進行手動迭代而沒有調用Dispose方法，就會產生資源泄漏。一般會使用foreach語句來迭代循環，因此這個問題不多會出現。可是仍是有必要意識到這個潛在的問題。

      該方法封裝了前三個步驟，這可能有點苛刻。將生命週期和方法進行封裝是有必要的，如今擴展一下，假如咱們要從網絡上讀取一個流文件，或者咱們想使用UTF-8編碼的方法，咱們須要將第一個部分暴漏給方法調用者，使得方法的調用簽名大體以下：

static IEnumerable<String> ReadLines(TextReader reader) 

這樣有不少很差的地方，咱們想對reader有絕對的控制，使得調用者可以在結束後能進行資源清理。問題在於，若是在第一次調用MoveNext()以前出現錯誤，那麼咱們就沒有機會進行資源清理工做了。IEnumerable<String>自身不能釋放，他存儲了某個狀態須要被清理。另外一個問題是若是GetEnumerator被調用兩次，咱們本意是返回兩個獨立的迭代器，而後他們卻使用了相同的reader。一種方法是，將返回類型改成IEnumerator<String>,但這樣的話，不能使用foreach進行迭代，並且若是沒有執行到MoveNext方法的話，資源也得不到清理。

   幸運的是，有一種方法能夠解決以上問題。就像代碼沒必要當即執行，咱們也不須要reader當即執行。咱們能夠提供一個接口實現「若是須要一個TextReader，咱們能夠提供」。在.NET 3.5中有一個代理，簽名以下：

public delegate TResult Func<TResult>()

代理沒有參數，返回和類型參數相同的類型。咱們想得到TextReader對象，因此可使用Func<TextReader>，代碼以下：

using (TextReader reader=provider())
{
    String line;
    while ((line=reader.ReadLine())!=null)
    {
        yield return line;
    }         
}

 

3.3 使用迭代塊和迭代條件來對集合進行進行惰性過濾

   LINQ容許對內存集合或者數據庫等多種數據源用簡單強大的方式進行查詢。雖然C#2沒有對查詢表達式，lambda表達及擴展方法進行集成。可是咱們也能達到相似的效果。

   LINQ的一個核心的特徵是可以使用where方法對數據進行過濾。提供一個集合以及過濾條件代理，過濾的結果就會在迭代的時候經過惰性匹配，每匹配一個過濾條件就返回一個結果。這有點像List<T>.FindAll方法，可是LINQ支持對全部實現了IEnumerable<T>接口的對象進行惰性求值。雖然從C#3開始支持LINQ，可是咱們也可使用已有的知識在必定程度上實現LINQ的Where語句。代碼以下：

public static IEnumerable<T> Where<T>(IEnumerable<T> source, Predicate<T> predicate)
{
    if (source == null || predicate == null)
        throw new ArgumentNullException();
    return WhereImpl(source, predicate);
}

private static IEnumerable<T> WhereImpl<T>(IEnumerable<T> source, Predicate<T> predicate)
{
    foreach (T item in source)
    {
        if (predicate(item))
            yield return item;
    }
}

IEnumerable<String> lines = ReadLines("FakeLinq.cs");
Predicate<String> predicate = delegate(String line)
{
    return line.StartsWith("using");
}; 

    如上代碼中，咱們將整個實現分爲了兩個部分，參數驗證和具體邏輯。雖然看起來奇怪，可是對於錯誤處理來講是頗有必要的。若是將這兩個部分方法放到一個方法中，若是用戶調用了Where<String>(null,null)，將不會發生任何問題，至少咱們期待的異常沒有拋出。這是因爲迭代塊的惰性求值機制產生的。在用戶迭代的時候第一次調用MoveNext方法以前，方法主體中的代碼不會執行，就像在2.2節中看到的那樣。若是你想急切的對方法的參數進行判斷，那麼沒有一個地方可以延緩異常，這使得bug的追蹤變得困難。標準的作法如上代碼，將方法分爲兩部分，一部分像普通方法那樣對參數進行驗證，另外一部分代碼使用迭代塊對主體邏輯數據進行惰性處理。

    迭代塊的主體很直觀，對集合中的逐個元素，使用predict代理方法進行判斷，若是知足條件，則返回。若是不知足條件，則迭代下一個，直到知足條件爲止。若是要在C#1中實現這點邏輯就很困難，特別是實現其泛型版本。

   後面的那段代碼演示了使用以前的readline方法讀取數據而後用咱們的where方法來過濾獲取line中以using開頭的行，和用File.ReadAllLines及Array.FindAll<String>實現這一邏輯的最大的差異是，咱們的方法是徹底惰性和流線型的(Streaming)。每一次只在內存中請求一行並對其進行處理，固然若是文件比較小的時候沒有什麼差異，可是若是文件很大，例如上G的日誌文件，這種方法的優點就會顯現出來了。

 

4 總結

   C#對許多設計模式進行了間接的實現，使得實現這些模式變得很容易。相對來針對某一特定的設計模式直接實現的的特性比較少。從foreach代碼中看出，C#1對迭代器模式進行了直接的支持，可是沒有對進行迭代的集合進行有效的支持。對集合實現一個正確的IEnumerable很耗時，容易出錯也很很枯燥。在C#2中，編譯器爲咱們作了不少工做，爲咱們實現了一個狀態機來實現迭代。

    本文還展現了和LINQ類似的一個功能：對集合進行過濾。IEnumerable<T>在LINQ中最重要的一個接口，若是想要在LINQ To Object上實現本身的LINQ操做，那麼你會由衷的感嘆這個接口的強大功能以及C#語言提供的迭代塊的用處。

    本文還展現了實際項目中使用迭代塊使得代碼更加易讀和邏輯性更好的例子，但願這些例子使你對理解迭代有所幫助。