C#枚举器，手动实现枚举器，可枚举集合，枚举器操作，迭代器

在C#语言中提供 foreach 查询操作，foreach 大大的简化了要编写的代码，但是foreach 只能用来遍历一个可枚举的集合（enumable），可枚举的集合就是实现了System.Collections.IEnumerable接口的一个集合。

但是foreach 返回的是可枚举对象的一个只读集合，不可以通过foreach 来修改可枚举对象。

简单的一个例子：

int[] number_array = new int[] { 1,2,3,4,5,6};

foreach (int k in number_array)

{

Console.WriteLine(k);

}

int 类型，继承了IEnumerable<T> 接口，所有可以用foreach 来遍历。如果我们自己写的一个类，没有实现IEnumerable<T> 接口，用foreach 就不能进行迭代了，编译器会报错。

例如：

自己写的一个类：

class Student: IComparable<Student>

{

public Student()

{

// nothing

}

private int age;

public int Age

{

get { return this.age;}

set { this.age = value; }

}

public int CompareTo(Student other)

{

//throw new NotImplementedException();

if (this.age == other.age)

{

return 0;

}

else if (this.age < other.age)

{

return -1;

}

else

{

return 1;

}

}

}

这个类实现了 IComparable<T> 接口，但是没有实现 IEnumerable<T> 接口，不能用foreach 遍历。

下面的代码对这个没有实现 IEnumerable<T> 接口的类进行foreach 遍历结果发生编译错误。

//Student[] student=new Student[5];

//student.test();

//foreach (Student t in student)

//{

//}

下面我们将自己手动的给上面那个简单的类实现枚举器，通过foreach来遍历这个类。

在 IEnumerable接口中，包括一个GetEnumerator的方法：

IEnumerator GetEnumertor();

这个方法返回一个枚举器对象。

IEnumerator 接口中规定了以下方法和属性：

object Current {get;}

bool MoveNext();

void Reset();

最初枚举器的指针指向枚举集合的第一个元素的前面，在获取 Current之前先要调用MoveNext() 使指针指向下一个元素。

以上所说的接口， 都有他们对应的泛型接口，在接下来的实现中，都会使用泛型接口。

当我们给要枚举的类实现了IEnumerable<T>接口后，foreach语句会自动的让生成一个枚举器，并通过枚举器中的Current, MoveNext等获取下一个数据，这一切过程对于foreach的使用者都是透明的。

下面，先给出本实例的所有代码，然后进行分析讲解。

所有原码如下：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace EnumerableTest

{

class Program

{

static void Main(string[] args)

{

int[] number_array = new int[] { 1,2,3,4,5,6};

foreach (int k in number_array)

{

Console.WriteLine(k);

}

//Student[] student=new Student[5];

////student.test();

//foreach (Student t in student)

//{

//}

Student[] student = new Student[5];

student[0] = new Student();

student[0].Age = 12;

student[1] = new Student();

student[1].Age = 13;

student[2] = new Student();

student[2].Age = 74;

student[3] = new Student();

student[3].Age = 34;

student[4] = new Student();

student[4].Age = 32;

Console.WriteLine("/////////////////////////////////////");

Sector<Student> sector = new Sector<Student>(student);

foreach (Student t in sector)

{

Console.WriteLine(t.Age);

}

}

}

class Sector<T> : IEnumerable<T>

where T : IComparable<T>

{

T[] student;

public Sector(T[] t)

{

student = t;

}

public IEnumerator<T> GetEnumerator()

{

return new SectorEnumator<T>(student);

//throw new NotImplementedException();

}

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

{

//throw new NotImplementedException();

return null;

}

}

class SectorEnumator<T> : IEnumerator<T>

where T : IComparable<T>

{

private T[] student;

private Queue<T> MyQueue;

private T currentItem;

public SectorEnumator(T[] s)

{

this.student = s;

}

public T Current

{

get { return this.currentItem; }

}

public void Dispose()

{

// simply do nothing

//throw new NotImplementedException();

}

object System.Collections.IEnumerator.Current

{

get { throw new NotImplementedException(); }

}

public bool MoveNext()

{

if (this.MyQueue == null)

{

MyQueue = new Queue<T>();

populate(student);

}

if (this.MyQueue.Count > 0)

{

this.currentItem = MyQueue.Dequeue();

return true;

}

return false;

//throw new NotImplementedException();

}

public void Reset()

{

//throw new NotImplementedException();

MyQueue.Clear();

populate(student);

}

private void populate(T[] s)

{

int num = s.Length;

for (int i = 0; i < num; i++)

{

MyQueue.Enqueue(s[i]);

}

}

}

class Student: IComparable<Student>

{

public Student()

{

// nothing

}

private int age;

public int Age

{

get { return this.age;}

set { this.age = value; }

}

public int CompareTo(Student other)

{

//throw new NotImplementedException();

if (this.age == other.age)

{

return 0;

}

else if (this.age < other.age)

{

return -1;

}

else

{

return 1;

}

}

}

}

首先，我们定义了一个Student 类，并实现了IComparable<T> 接口，我们程序的目的就是在使用Student类的时候，可以通过foreach 来遍历Student数组中的每个成员，但是默认情况下Student类并没有实现IEnumberable<T>接口，所有在直接用foreach 遍历的时候会编译报错。

为了遍历Student类，我们手动实现了一个枚举器。

class SectorEnumator<T> : IEnumerator<T>

where T : IComparable<T>

{

private T[] student;

private Queue<T> MyQueue;

private T currentItem;

public SectorEnumator(T[] s)

{

this.student = s;

}

public T Current

{

get { return this.currentItem; }

}

public void Dispose()

{

// simply do nothing

//throw new NotImplementedException();

}

object System.Collections.IEnumerator.Current

{

get { throw new NotImplementedException(); }

}

public bool MoveNext()

{

if (this.MyQueue == null)

{

MyQueue = new Queue<T>();

populate(student);

}

if (this.MyQueue.Count > 0)

{

this.currentItem = MyQueue.Dequeue();

return true;

}

return false;

//throw new NotImplementedException();

}

public void Reset()

{

//throw new NotImplementedException();

MyQueue.Clear();

populate(student);

}

private void populate(T[] s)

{

int num = s.Length;

for (int i = 0; i < num; i++)

{

MyQueue.Enqueue(s[i]);

}

}

}

在MOveNext() 中，如果这个枚举器的MyQueue为null，则new 一个Queue, 用MyQueue存放给枚举器传进来的对象数组。每一次MoveNext() 都会造成一个对象出队。

然后给一个类实现IEnumerable<T> 接口，通过GetEnumerator() 方法获取枚举器：

class Sector<T> : IEnumerable<T>

where T : IComparable<T>

{

T[] student;

public Sector(T[] t)

{

student = t;

}

public IEnumerator<T> GetEnumerator()

{

return new SectorEnumator<T>(student);

//throw new NotImplementedException();

}

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

{

//throw new NotImplementedException();

return null;

}

}

这样，在我们以后创建一个Sector 对象以后，就可以直接用foreach 对Sector对象中的Student 对象进行枚举:

Sector<Student> sector = new Sector<Student>(student);

foreach (Student t in sector)

{

Console.WriteLine(t.Age);

}