.Net编程接口剖析系列之迭代器zz - 风生水起

在上一篇文章中，我们讲了IComparable和IComparer接口，而在本篇文章中，我要给大家讲讲用于枚举元素集合的两个接口 IEnumerator和IEnumerable。IEnumerator用于实现一个迭代器（相当于以前C++的文章中所说的iterator），它具备列举一个数据结构中所有元素所需要的一些方法和属性。而IEnumerable接口则用于返回一个迭代器对象，一个实现了IEnumerable的类型表示这个类型对象是可以枚举的。
下面我们先来看看这两个接口的定义吧!

IEnumerator

迭代器用于枚举一个数据结构中的所有元素。

 namespace System.Collections 
{ 
[ComVisible(true)] 
[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")] 
public interface IEnumerable 
{ 
[DispId(-4)] 
IEnumerator GetEnumerator(); 
} 
}

   从上面的定义我们可以看到，一个Emurator具备了枚举一个数据结构中所有元素的最基本能力：
   获取当前元素的的能力：Current属性；
   移动元素指针的能力：MoveNext方法；
   重置迭代器的能力：Reset方法。
   这里的Current属性是Object类型，也就是可以返回所有类型元素，而与之对应的泛型接口是：System.Collections.Generic.IEnumerator<T>，它除了继承了Ienumerator之外，还增加了一个特定类型的Current属性。
IEnumerable
   IEnumerable声明一个类型为可枚举的类型，而它的定义很简单，就是返回一个迭代器。

namespace System.Collections 
{ 
[ComVisible(true)] 
[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]

我们应该对C#风格的遍历语法应该很熟悉了，也就是foreach语句。说到foreach这个东西，其实在C++中也存在，但是是以函数的形式做在库里面的，而对C#来说，它已经被做到语言中去了。在绝大多数情形下，我们应该尽量使用foreach语句来遍历一个集合对象，而不是自己写一个for循环或者其他的while循环等，理由很简单：效率。而foreach语法需要被枚举的对象类型实现了IEnumerable接口。
与IEnumerable对应的泛型接口是：System.Collections.Generic.IEnumerable<T>。

设计一个集合类

通常，IEnumerator和IEnumerable是一起使用的。假设我们设计一个属于自己的一个数据结构类MyCollection，并且让他可以被枚举，那么整体上应该怎么设计呢？我们看看下面的代码。

class MyCollection:IEnumerable 
{ 
public struct MyEmurator : IEnumerator 
{ 
//此处省略实现代码 
} 
//此处省略部分实现代码 
public IEnumerator GetEnumerator() 
{ 
return new MyEmurator(this); 
} 
}

   这是一个典型的对IEnumerator和IEnumerable的应用方式。几乎所有的System.Collection里面的容器都是都是这样来设计的。将容器类型本身实现IEnumerable，表明容器是可枚举的。而迭代器类型则是一个嵌套类型，通过容器类的接口函数GetEnumerator 来返回迭代器的实例。通常一个容器和它的迭代器是紧密相关的，并且一个容器配备一个迭代器已经足以，那么将迭代器定义为嵌套类型，避免了管理的混乱。

实现一个2D List类型

    我们这里说的二维List类型，其实就是实现一个以List为元素的List，简而言之，这个List2D就是用来存放List的一个List；但是我们枚举的时候，并不想要枚举List2D里面的list, 而是想直接枚举list里面的元素。
    我们这里定义了一个泛型类List2D<T> ，实现了IEnumerable<T>接口。这里为了精简代码，这里没有让List2D实现IList接口，只提供了Add、Clear等几个简单方法。不多说了，还是来看看下面的代码吧！

class List2D<T> : IEnumerable<T> 
{ 
//内嵌迭代器类型 
public struct Emurator : IEnumerator<T> 
{ 
//此处代码先不写出 
} 
private List<List<T>> _lists=new List<List<T>>();//存储列表 

public List<T> this[int index] 
{ 
get { return _lists[index]; } 
} 

public int Count 
{ 
get 
{ 
int count = 0; 
foreach (List<T> list in _lists) 
{ 
count += list.Count; 
} 
return count; 
} 
} 

public void Add(List<T> item) 
{ 
_lists.Add(item); 
} 

public void Clear() 
{ 
_lists.Clear(); 
} 

#region IEnumerable Members 

public IEnumerator GetEnumerator() 
{ 
return ((IEnumerable<T>)this).GetEnumerator(); 
} 
#endregion 

#region IEnumerable<T> Members 

IEnumerator<T> IEnumerable<T>.GetEnumerator() 
{ 
return new Emurator(this); 
} 
#endregion 
}

我们再来看看迭代器类型struct Emurator的定义，它是嵌套在List2D之中的，它实现了IEnumerator<T>接口。迭代器的实现详见注释。

class List2D<T> : IEnumerable<T> 
{ 
public struct Emurator : IEnumerator<T> 
{ 
List2D<T> _list2D; //被枚举的2D list 
IEnumerator<List<T>> _listsEmuretor; //列表迭代器 
IEnumerator<T> _listEmuretor; //元素迭代器 
bool _started; //是否开始枚举 
T _current; //当前元素 

public Emurator(List2D<T> list2D) 
{ 
_list2D=list2D; 
_listsEmuretor = list2D._lists.GetEnumerator(); 
_listEmuretor=default(IEnumerator<T>); 
_started = false; 
_current = default(T); 
} 

#region IEnumerator Members 

public object Current 
{ 
get { return _current; } 
} 

public bool MoveNext() 
{ 
if (!_started) //第一次MoveNext, 需要取第一个列表 
{ 
_started = true; 
if (!_listsEmuretor.MoveNext()) 
return false; 

_listEmuretor = _listsEmuretor.Current.GetEnumerator(); //获取第一个list的迭代器 
} 

while(true) 
{ 
if (!_listEmuretor.MoveNext()) 
{ 
//当前列表枚举结束，需要移动到一个列表 
if (!_listsEmuretor.MoveNext()) 
return false; //所有列表遍历完毕，返回false 

_listEmuretor = _listsEmuretor.Current.GetEnumerator(); 
} 
else //当前列表还有元素，成功 
{ 
_current = _listEmuretor.Current; 
return true; 
} 
} 
} 

public void Reset() 
{ 
_listsEmuretor.Reset(); 
_current = default(T); 
_started = false; 
} 
#endregion 

#region IEnumerator<T> Members 
T IEnumerator<T>.Current 
{ 
get { return _current; } 
} 
#endregion 

public void Dispose() 
{ 
} 
} 
}

真不容易，写了好些代码才把这个2D List的迭代器实现。我们在Main函数里面写一些测试代码，看看它能否正常运行。

static void Main(string[] args) 
{ 
List2D<string> list2D = new List2D<string>();//2维string列表 

List<string> list1 = new List<string>(); 
list1.Add("list1-1"); 
list1.Add("list1-2"); 
list1.Add("list1-3"); 
list2D.Add(list1); //第一个列表有3个元素 

List<string> list2 = new List<string>(); 
list2D.Add(list2);//第二个列表没有元素 

List<string> list3 = new List<string>(); 
list1.Add("list3-1"); 
list1.Add("list3-2"); 
list2D.Add(list3); //第三个列表有2个元素 

foreach (string str in list2D)//枚举所有string 
{ 
Console.WriteLine(str); 
} 

Console.ReadKey();

   运行结果如下。
   list1-1
   list1-2
   list1-3
   list3-1
   list3-2
   我们可以看到运行结果完全正确。

Yield Return

从前面我们可能发现，有时候写一个迭代器可能是挺麻烦的一个事情，其实需求却可能是挺简单的，但是我们却要写大量代码来实现一个迭代器。所幸的是，C#给我们提供一个独门利器：Yield Return! 利用yield return，我们不需要写一个迭代器就能够实现GetEnumerator函数了。
Yield return不同于普通函数的Return，它从作用上来说，相当于每调用一次yield return，就返回一个被枚举的元素。Yield Return语法只能用在返回值类型为IEnumerator的函数中。我们现在来看看，List2D的GetEnumerator函数如何用yield return来实现，从而使我们不用再创建一个自定义的Emurator类型。

 IEnumerator<T> IEnumerable<T>.GetEnumerator() 
{ 
foreach (List<T> list in _lists) 
{ 
foreach (T item in list) 
{ 
yield return item; 
} 
} 
}

    7行！包括4个花括弧仅仅用了7行代码，就实现了一个迭代器的所有功能，而前面我们为了实现一个迭代器，写了数十行的代码，这对编码效率上来说，这是多么大的一个提升啊。当然，并非所有情形下，用yield return都是合适，但是在一般的需求之下，它是最好的选择。
习惯了传统编程语言的人，可能会比较难易理解Yield Return这个东西，而且更会对它是到底是如何实现的充满了疑问。其实Yield Return是C#从语言层面上提供的一种简化代码的语法形式而已，而归根到底，其实是C#的编译器辅助我们完成了一部分编码工作—它为我们自动创建了一个匿名的迭代器类型，并且用那个迭代器实现了我们在使用yield return语义所实现的迭代功能。
    如果你对上面的论断产生怀疑的话，我们可以借助VS.net自带的IL查看工具ildasm.exe来查看我们用yield return代码编译后的exe文件。Ildasm.exe (VS2005)通常存放在“C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\Bin\”目录下。
    从下面Ildasm.exe的截图中我们可以看见List2D类型中有个嵌套类型GetEnumerator>d__0<T>，而这个恰恰就是C#编译器为我们生成的匿名迭代器类型。

在感叹C#编译器的智能的时候，我们有必要对yield return的实现做一个更加深入的了解，那就是查看它自动生成的迭代器的代码究竟是怎么样的，与我们自己写的迭代器相比，究竟有多大差别。使用 ildasm可以查看IL代码，不过这是非常痛苦的一件事情，即使你对IL的所有指令都背得滚瓜烂熟，同样也是一间非常痛苦的事情。所以，这里我想向大家推荐一个代码学习利器，.Net的反编译器“.Net Reflector”，它可以将编译好的.Net程序反编译为C#代码，并且有着比较高的还原率，而且这个工具本身还在不断升级当中。你可以从 http://www.aisto.com/roeder/dotnet免费下载这个软件。
Yield Return可以在GetEnumerator函数中任意地方使用，而我们的程序结构一般会包括顺序结构、循环和分支选择等。为了弄清编译器对yield return的处理细节，我们先设计一个简单的类，它仅仅使用yield return先返回一个-1，再返回一个100，然后就结束了，这是一个再简单不过的顺序执行结构了，下面是这个类的代码：

class TestYieldReturn:IEnumerable 
{ 
public IEnumerator GetEnumerator() 
{ 
yield return -1; 
yield return 100; 
} 
}

我们将这段程序编译好，然后用.NET Reflactor将其进行反编译，于是我们得到了编译器自动生成的迭代器的代码：

[CompilerGenerated] 
private sealed class <GetEnumerator>d__0 : IEnumerator<object>, IEnumerator, IDisposable 
{ 
// Fields 
private int <>1__state; 
private object <>2__current; 
public TestYieldReturn <>4__this; 

// Methods 
[DebuggerHidden] 
public <GetEnumerator>d__0(int <>1__state) 
{ 
this.<>1__state = <>1__state; 
} 

private bool MoveNext() 
{ 
switch (this.<>1__state) 
{ 
case 0: 
this.<>1__state = -1; 
this.<>2__current = -1;//首先返回-1 
this.<>1__state = 1; 
return true; 

case 1: 
this.<>1__state = -1; 
this.<>2__current = 100;//再返回100 
this.<>1__state = 2; 
return true; 

case 2: 
this.<>1__state = -1; //已经到了末尾，设置状态为结束 
break; 
} 
return false; 
} 

[DebuggerHidden] 
void IEnumerator.Reset() 
{ 
throw new NotSupportedException(); 
} 

void IDisposable.Dispose() 
{ 
} 

// Properties 
object IEnumerator<object>.Current 
{ 
[DebuggerHidden] 
get 
{ 
return this.<>2__current; 
} 
} 
object IEnumerator.Current 
{ 
[DebuggerHidden] 
get 
{ 
return this.<>2__current; 
} 
} 
}

我们能看到这个迭代器类型的前面有个Attribute：[CompilerGenerated]，这表明这个迭代器确实属于编译器生成无疑。迭代器的成员变量除了current和被枚举对象“<>4__this”之外，还增加了一个“<>1__state”的成员，而这个 state，真是用于实现顺序程序结构的状态变量，我们可以分析一下最重要的MoveNext函数，State的0、1、2分别代表第一个yield return之前，第一个yield return之后，第二个yield return之后的程序状态，而-1代表枚举结束。编译器就是用state成员变量来控制顺序逻辑的先后次序。
类似的，C#编译器通过设定一些其他的辅助变量，来实现循环和分支等控制结构。有时候这几种结构是相互组合的，编译器都能够很好的实现他们。

Version控制

我们来看看这段代码，它想把列表中的所有负数给删除掉。

List<int> list=new List<int>(); 
list.Add(0); 
list.Add(-1); 
list.Add(2); 

foreach(int i in list) 
{ 
if(i<0) list.Remove(i); 
}

     这段代码看起来似乎写的没有问题，编译也能通过。但是真正跑起来就会抛出异常了。它将会抛出一个InvalidOperationException，错误信息是"Collection was modified; enumeration operation may not execute."。
    怎么会这样呢？原来是微软在定义迭代器功能的时候，要求在枚举开始到结束的这个过程之中，应该要求保证被枚举的对象不能够增加或者减少元素。其实这个需求也很好理解，相信谁也不想在清点队伍人数的时候，队伍里面的人还在出出进进吧？
    这里善于思考的读者可能马上会想到一个问题，迭代器又是如何知道这个集合发生改变了呢？这里微软用了一个简单而巧妙的办法，给集合对象设置了一个版本信息，通过在迭代过程中不断检查版本信息，来判断集合对象是否已经被更新。具体的做法如下。
1. 给集合对象增加一个成员private int _version，初始值设置为0；
2. 在所有直接对集合元素进行更新的操作中，例如insert、remove等等，都将_version ++;
3. Enumerator也设置一个_version成员，并且在构造函数中将其设置为集合对象的_version成员。其实也就是记录了collection当时的版本。
4. Enumerator在迭代的过程中，不断检查collection的_version字段，一旦发现与当初记录的_version值不同，则认定为集合已经被更新，立即抛出异常。

一点感言

    从foreach到yield return还有C#3.X的LINQ等等，我们发现C#正在为我们越来越多的事情，但是我们不知道这种变化何时是尽头，也不知道我们的学习何时是尽头。 C#引入这些新特性是希望不断简化我们的编码工作，但是与此同时难免也会带来一些新的问题，那就是C#正在变得越来越庞大和复杂，也许有一天我们会发现，自己都不知道什么是C#了，也许把什么都做入语言层面并非是一件好事。天天有新技术的感觉是不错，不过昨天的新技术在今天立马就变成了旧技术却可能是一件令人沮丧的事情。我们需要创新，但是更加需要经典，C#何时才能成为经典？

posted on 2011-08-25 10:56 风生水起阅读(607) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部