C#迭代器（Foreach）实现方法

一、为非泛型列表创建迭代器块
using System;
using System.Collections.Generic;
using System.Text;

namespace ForeachConstruct
{
/*
* 下面的代码示例阐释如何编写可与foreach 一起使用的非泛型集合类。
* 该类是字符串标记化拆分器，类似于C 运行时库函数strtok。
* 此示例描述的是只有在您无法使用泛型集合类时才采用的推荐做法。
* C# 语言和.NET Framework 的2.0 版和更高版本支持泛型。
* 在下面的示例中，Tokens 使用“”和“-”作为分隔符将句子“This is a sample sentence.-yang lei”
* 拆分为标记，并使用foreach 语句枚举这些标记：
*/

#region 省略接口
/*
* 在C# 中，集合类并非必须严格从IEnumerable 和IEnumerator 继承才能与foreach 兼容；
* 只要类有所需的GetEnumerator、MoveNext、Reset 和Current 成员，便可以与foreach 一起使用。
* 省略接口的好处为，使您可以将Current 的返回类型定义得比object 更明确，
* 从而提供了类型安全。
* 省略IEnumerable 和IEnumerator 的缺点是，
* 集合类不再能够与其他公共语言运行库兼容语言的foreach 语句或等效项交互操作
*/
/*
public class Tokens
{
private string[] elements;

public Tokens(string source, char[] delimiters)
{
elements = source.Split(delimiters);
}

#region IEnumerable 成员

public TokenEnumerator GetEnumerator()
{
return new TokenEnumerator(this);
}
#endregion

public class TokenEnumerator
{
private int position = -1;
private Tokens t;

public TokenEnumerator(Tokens t)
{
this.t = t;
}

#region IEnumerator 成员

public string Current
{
get
{
return t.elements[position];
}
}

public bool MoveNext()
{
if (position < t.elements.Length - 1)
{
position++;
return true;
}
else
{
return false;
}
}

public void Reset()
{
position = -1;
}

#endregion
}
}
*/
#endregion

#region 实现接口
/*
* 您可以同时拥有两者的优点，即C# 中的类型安全以及与其他公共语言运行库兼容语言的互操作性，
* 方法是从IEnumerable 和IEnumerator 继承并使用显式接口实现。
*/
public class Tokens : System.Collections.IEnumerable
{
private string[] elements;

public Tokens(string source, char[] delimiters)
{
elements = source.Split(delimiters);
}

#region IEnumerable 成员

public System.Collections.IEnumerator GetEnumerator()
{
return new TokenEnumerator(this);
}

#endregion

public class TokenEnumerator : System.Collections.IEnumerator
{
private int position = -1;
private Tokens t;

public TokenEnumerator(Tokens t)
{
this.t = t;
}

#region IEnumerator 成员

public object Current
{
get
{
return t.elements[position];
}
}

public bool MoveNext()
{
if (position < t.elements.Length - 1)
{
position++;
return true;
}
else
{
return false;
}
}

public void Reset()
{
position = -1;
}

#endregion
}
}
#endregion

class Program
{
static void Main(string[] args)
{
Tokens f = new Tokens("This is a sample sentence.-yang lei", new char[] { ' ', '-' });

foreach (string item in f)
{
System.Console.WriteLine(item);
}
}
}

/*
* 输出
This
is
a
sample
sentence.
yang
lei
请按任意键继续. . .
*/
}

二、为泛型列表创建迭代器块
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace ForeachConstruct
{
//为泛型列表创建迭代器块
public class Stack<T> : IEnumerable<T>
{
private T[] values = new T[100];
private int top = 0;

public void Push(T t)
{
values[top++] = t;
}

public T Pop()
{
return values[--top];
}

public IEnumerable<T> TopToBottom
{
get { return this; }
}

public IEnumerable<T> BottomToTop
{
get
{
for (int i = 0; i < top; i++)
{
yield return values[i];
}
}
}

public IEnumerable<T> TopN(int n)
{
int j = (n >= top) ? 0 : top - n;

for (int i = top; --i >= j; )
{
yield return values[i];
}
}

#region IEnumerable<T> 成员

public IEnumerator<T> GetEnumerator()
{
for (int i = top; --i >= 0; )
{
yield return values[i];
}
}

#endregion

#region IEnumerable 成员

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

#endregion
}

class Test
{
static void Main()
{
Stack<int> s = new Stack<int>();
for (int i = 0; i < 10; i++)
{
s.Push(i);
}

foreach (int n in s)
{
System.Console.Write("{0} ", n);
}
System.Console.WriteLine();

foreach (int n in s.TopToBottom)
{
System.Console.Write("{0} ", n);
}
System.Console.WriteLine();

foreach (int n in s.BottomToTop)
{
System.Console.Write("{0} ", n);
}
System.Console.WriteLine();

foreach (int n in s.TopN(7))
{
System.Console.Write("{0} ", n);
}
System.Console.WriteLine();
}
}

/*
* 输出
9 8 7 6 5 4 3 2 1 0
9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3
请按任意键继续. . .
*/

/* yield的说明
* 在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一：
yield return expression;
yield break;
*
参数
expression
进行计算并以枚举数对象值的形式返回。expression 必须可以隐式转换为迭代器的yield 类型。
*
备注
yield 语句只能出现在iterator 块中，该块可用作方法、运算符或访问器的体。
这类方法、运算符或访问器的体受以下约束的控制：
不允许不安全块。
方法、运算符或访问器的参数不能是ref 或out。
yield 语句不能出现在匿名方法中。
当和expression 一起使用时，yield return 语句不能出现在catch 块中或含有一个或多个catch 子句的try 块中。
*
包含yield语句的方法或属性称为迭代块。迭代块必须声明为返回IEnumerator或IEnumerable接口.
yield语句从本质上讲是运用了延迟计算(Lazy evaluation或delayed evaluation)的思想。
在Wiki上可以找到延迟计算的解释：将计算延迟，直到需要这个计算的结果的时候才计算，
这样就可以因为避免一些不必要的计算而改进性能，在合成一些表达式时候还可以避免一些不必要的条件，
因为这个时候其他计算都已经完成了，所有的条件都已经明确了，有的根本不可达的条件可以不用管了。
*/

}