C#學習筆記（三）—–try語句和異常

列舉型別

• enumerator是隻讀的、只能在序列的值上向前移動的遊標。一個enumerator是一個實現了下列任一介面的物件：
  ①System.Collections.IEnumerator
  ②System.Collections.Generic.IEnumerator<T>
  技術上講，任何一個實現了MoveNext方法和Current屬性的物件都可以被看作是一個enumerator（這就叫做鴨子型別，duck type）。這個寬泛的概念是在C#1.0的時候被引進的，目的是不用裝箱和拆箱就可以對值型別的元素進行列舉。但是在C#2.0中，由於泛型的引入，這個功能變得多餘了（這個優點在泛化的概念出現後就不存在了，而且實際上C#2.0已經不支援了）。

• foreach語句可以用來在可列舉的物件上執行迭代操作，一個可列舉的物件是一個序列的邏輯上的表現。它本身不是一個遊標，但他自身會產生遊標（S）。一個可列舉物件可以是：
  ①：實現了IEnumerable or IEnumerable<T>介面
  ②：具有一個GetEnumerator方法並且返回一個enumerator
  提示：IEnumerator 和 IEnumerable 定義在 System.Collections名稱空間中，IEnumerator<T> 和 IEnumerable<T> 定義在System.Collections.Generic名稱空間中

• 列舉模式如下所示：

class Enumerator // 通常實現了IEnumerator或IEnumerator<T>
{
public IteratorVariableType Current { get {...} }
public bool MoveNext() {...}
}
class Enumerable // 通常實現了IEnumerable 或 IEnumerable<T>
{
public Enumerator GetEnumerator() {...}
}

• 下面是用高階方法即foreach語句實現對單詞beer的迭代：

foreach (char
 
 c in "beer")
Console.WriteLine (c);

• 下面使用低階方法即不用foreach語句，實現對單詞beer的迭代：

using (var enumerator = "beer".GetEnumerator())
while (enumerator.MoveNext())
{
var element = enumerator.Current;
Console.WriteLine (element);
}

如果enumerator實現了IDisposable，那麼foreach語句也實現了using語句的作用，可以隱式釋放enumerator物件。

集合初始化方法

• 可以通過一個簡單的步驟建立和填充一個可列舉的物件：

using System.Collections.Generic;
...
List<int> list = new List<int> {1, 2, 3};

編譯器將這部分翻譯為下面的程式碼：

using System.Collections.Generic;
...
List<int> list = new List<int>();
list.Add (1);
list.Add (2);
list.Add (3);

這要求可列舉的物件實現System.Collections.IEnumerable介面，並且有add方法以及適合的引數來被呼叫。

迭代器

• 和foreach是可列舉物件的使用者相對應的是迭代器是可列舉物件的生產者。本例中我們使用迭代器返回斐波那契數列表（斐波那契數列的定義是每個數字是前兩個數字之和）：

using System;
using System.Collections.Generic;
class Test
{
static void Main()
{
foreach (int fib in Fibs(6))
Console.Write (fib + " ");
}
static IEnumerable<int> Fibs (int fibCount)
{
for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
{
yield return prevFib;
int newFib = prevFib+curFib;
prevFib = curFib;
curFib = newFib;
}
}
}

鑑於return語句表達的是“這是你要求我從方法返回的值”的意思，yield return語句表達的是“這是你要求我從enumerator產生的下一個元素”，在每一個yield語句中，控制返回呼叫者（caller），但是被呼叫者（callee）的狀態被保持以便呼叫者（caller）想要列舉下一個值的時候立刻繼續執行。這個狀態的生命週期被繫結到enumerator上，以便當呼叫者結束列舉時狀態可以被及時釋放。
提示：編譯器將迭代方法轉換為實現了IEnumerable<T> 與/或 IEnumerator<T>.的私有類，迭代器的邏輯在編譯器寫的列舉類中，被反轉並連線MoveNEext方法和Current屬性，這表明當呼叫迭代方法時，所做的只是例項化編譯器寫的類，編寫的程式碼並不真正執行，編寫的程式碼只有在開始遍歷結果序列時才會真正執行，典型的如foreach語句。下面是Fibs方法在後臺生成的類：

[CompilerGenerated]
private sealed class <Fibs>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
{
// Fields
private int <>1__state;
private int <>2__current;
public int <>3__fibCount;
private int <>l__initialThreadId;
public int <curFib>5__3;
public int <i>5__1;
public int <newFib>5__4;
public int <prevFib>5__2;
public int fibCount;
// Methods
[DebuggerHidden]
public <Fibs>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
this.<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
private bool MoveNext()
{
switch (this.<>1__state)
{
case 0:
this.<>1__state = -1;
this.<i>5__1 = 0;
this.<prevFib>5__2 = 1;
this.<curFib>5__3 = 1;
while (this.<i>5__1 < this.fibCount)
{
this.<>2__current = this.<prevFib>5__2;
this.<>1__state = 1;
return true;
Label_0057:
this.<>1__state = -1;
this.<newFib>5__4 = this.<prevFib>5__2 + this.<curFib>5__3;
this.<prevFib>5__2 = this.<curFib>5__3;
this.<curFib>5__3 = this.<newFib>5__4;
this.<i>5__1++;
}
break;
case 1:
goto Label_0057;
}
return false;
}
[DebuggerHidden]
IEnumerator<int> IEnumerable<int>.GetEnumerator()
{
Program.<Fibs>d__0 d__;
if ((Environment.CurrentManagedThreadId == this.<>l__initialThreadId) && (this.<>1__state == -2))
{
this.<>1__state = 0;
d__ = this;
}
else
{
d__ = new Program.<Fibs>d__0(0);
}
Page 1 of 2
about:blank 2017-05-22
d__.fibCount = this.<>3__fibCount;
return d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator() =>
this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
void IDisposable.Dispose()
{
}
// Properties
int IEnumerator<int>.Current =>
this.<>2__current;
object IEnumerator.Current =>
this.<>2__current;
}
Collapse Methods
Page 2 of 2
about:blank 2017-05-22

迭代器語義

• 迭代器是包含一個或多個yield語句的方法、屬性、或索引器。迭代器必須返回下列四個介面之一（否則，編譯器會報錯）：
  //IEnumerable介面
  System.Collections.IEnumerable
System.Collections.Generic.IEnumerable<T>
  //IEnumerator介面
  System.Collections.IEnumerator
System.Collections.Generic.IEnumerator<T>
  返回enumerable和返回enumerator的介面具有不同語義，我們將在後續的筆記中做詳細的介紹。
• 允許使用多個yield語句：

class Test
{
static void Main()
{
foreach (string s in Foo())
Console.WriteLine(s); // Prints "One","Two","Three"
}
static IEnumerable<string> Foo()
{
yield return "One";
yield return "Two";
yield return "Three";//使用多個yield語句
}
}

• yield break語句：該語句表明迭代器不返回後面的元素而提前結束。我們可以把Foo修改成下面的示例：

static IEnumerable<string> Foo (bool breakEarly)
{
yield return "One";
yield return "Two";
if (breakEarly)
yield break;
yield return "Three";
}

在迭代器塊中使用return語句是不合法的，應該用yield return來代替。

迭代器和try/catch/finally

• yield語句不能出現在帶catch塊的try語句塊中。

IEnumerable<string> Foo()
{
try { yield return "One"; } // 不合法
catch { ... }
}

yield return也不能出現在catch和finally語句塊中，出現這些限制的原因是編譯器必須將迭代器轉換為帶有state、current、movenext和dispose成員的普通類。而且轉換普通類可能會大大增加程式碼的複雜性。
但是，可以在只帶有finally塊的try語句塊中使用yield return：

IEnumerable<string> Foo()
{
try { yield return "One"; } // OK
finally { ... }
}

當列舉器到達序列末尾或者呼叫dispose時候，finally塊中程式碼就會執行了，如果你提前使用了break語句，foreach語句會隱式的中斷列舉器。這是一種正確的使用列舉器的方法。當顯式的使用一個列舉器時，有一個陷阱是需要注意的：在沒有關閉它的情況下提前放棄了列舉器。這使得finally語句塊失去了作用。你可以顯式的通過使用using語句來規避這一風險。

string firstElement = null;
var sequence = Foo();
using (var enumerator = sequence.GetEnumerator())
if (enumerator.MoveNext())
firstElement = enumerator.Current;

組合序列

• 迭代器具有高度可組合性：我們擴充套件示例，這次只輸出斐波那契數列中的偶數（注意讀中文版的同學這裡的翻譯又開始嚴重的抽抽了，我詛咒這幫王八蛋）：

using System;
using System.Collections.Generic;
class Test
{
static void Main()
{
foreach (int fib in EvenNumbersOnly (Fibs(6)))
Console.WriteLine (fib);
}
static IEnumerable<int> Fibs (int fibCount)
{
for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
{
yield return prevFib;
int newFib = prevFib+curFib;
prevFib = curFib;
curFib = newFib;
}
}
static IEnumerable<int> EvenNumbersOnly (IEnumerable<int> sequence)
{
foreach (int x in sequence)
if ((x % 2) == 0)
yield return x;
}
}

每一個元素直到最後才會被計算–當通過MoveNext()進行操作的時候。下圖顯示了隨時間變化的資料請求和輸出：

提示：為什麼我在這裡放一張英文的原圖來代替翻譯後的圖，因為中文版的翻譯這個圖上本來就是錯的。我沒辦法，只有將原圖找來了。還是那句話。我從來沒見過一本書會被翻譯的如此不負責任。多麼好的一本書。徹底毀了。

迭代器模式中的可組合性在linq中是非常有用的，這將在後續的筆記中陸續進行討論。