IEnumerable和IEnumerator 详解 【转】

初学C#的时候，老是被IEnumerable、IEnumerator、ICollection等这样的接口弄的糊里糊涂，我觉得有必要切底的弄清楚IEnumerable和IEnumerator的本质。

下面我们先看IEnumerable和IEnumerator两个接口的语法定义。其实IEnumerable接口是非常的简单，只包含一个抽象的方法GetEnumerator()，它返回一个可用于循环访问集合的IEnumerator对象。IEnumerator对象有什么呢？它是一个真正的集合访问器，没有它，就不能使用foreach语句遍历集合或数组，因为只有IEnumerator对象才能访问集合中的项，假如连集合中的项都访问不了，那么进行集合的循环遍历是不可能的事情了。那么让我们看看IEnumerator接口有定义了什么东西。看下图我们知道IEnumerator接口定义了一个Current属性，MoveNext和Reset两个方法，这是多么的简约。既然IEnumerator对象时一个访问器，那至少应该有一个Current属性，来获取当前集合中的项吧。

MoveNext方法只是将游标的内部位置向前移动（就是移到一下个元素而已），要想进行循环遍历，不向前移动一下怎么行呢？

详细讲解：

说到IEnumerable总是会和IEnumerator、foreach联系在一起。

C# 支持关键字foreach，允许我们遍历任何数组类型的内容：

//遍历数组的项

int[] myArrayOfInts = {10,20,30,40};

foreach(int i in my myArrayOfInts)

{

Console.WirteLine(i);

}

虽然看上去只有数组才可以使用这个结构，其实任何支持GetEnumerator()方法的类型都可以通过foreach结构进行运算。

1. public class Garage
2. {
3. Car[] carArray = new Car[4];  //在Garage中定义一个Car类型的数组carArray,其实carArray在这里的本质是一个数组字段
4. //启动时填充一些Car对象
5. public Garage()
6. {
7. //为数组字段赋值
8. carArray[0] = new Car("Rusty", 30);
9. carArray[1] = new Car("Clunker", 50);
10. carArray[2] = new Car("Zippy", 30);
11. carArray[3] = new Car("Fred", 45);
12. }
13. }

    public class Garage
    {
        Car[] carArray = new Car[4];  //在Garage中定义一个Car类型的数组carArray,其实carArray在这里的本质是一个数组字段

        //启动时填充一些Car对象
        public Garage()
        {
            //为数组字段赋值
            carArray[0] = new Car("Rusty", 30);
            carArray[1] = new Car("Clunker", 50);
            carArray[2] = new Car("Zippy", 30);
            carArray[3] = new Car("Fred", 45);
        }
    }
 

理想情况下，与数据值数组一样，使用foreach构造迭代Garage对象中的每一个子项比较方便：

1. //这看起来好像是可行的
2. lass Program
3. {
4. static void Main(string[] args)
5. {
6. Console.WriteLine("*********Fun with IEnumberable/IEnumerator************\n");
7. Garage carLot = new Garage();
8. //交出集合中的每一Car对象吗
9. foreach (Car c in carLot)
10. {
11. Console.WriteLine("{0} is going {1} MPH", c.CarName, c.CurrentSpeed);
12. }
13. Console.ReadLine();
14. }
15. }

 //这看起来好像是可行的
class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("*********Fun with IEnumberable/IEnumerator************\n");
            Garage carLot = new Garage();

            //交出集合中的每一Car对象吗
             foreach (Car c in carLot)
            {
                Console.WriteLine("{0} is going {1} MPH", c.CarName, c.CurrentSpeed);
            }

            Console.ReadLine();
        }
    }

让人沮丧的是，编译器通知我们Garage类没有实现名为GetEnumerator()的方法（显然用foreach遍历Garage对象是不可能的事情，因为Garage类没有实现GetEnumerator()方法，Garage对象就不可能返回一个IEnumerator对象，没有IEnumerator对象，就不可能调用方法MoveNext()，调用不了MoveNext，就不可能循环的了）。这个方法是有隐藏在System.collections命名空间中的IEnumerable接口定义的。（特别注意，其实我们循环遍历的都是对象而不是类，只是这个对象是一个集合对象）

支持这种行为的类或结构实际上是宣告它们向调用者公开所包含的子项：

//这个接口告知调方对象的子项可以枚举

public interface IEnumerable

{

IEnumerator GetEnumerator();

}

可以看到，GetEnumerator方法返回对另一个接口System.Collections.IEnumerator的引用。这个接口提供了基础设施，调用方可以用来移动IEnumerable兼容容器包含的内部对象。

//这个接口允许调用方获取一个容器的子项

public interface IEnumerator

{

bool MoveNext();             //将游标的内部位置向前移动

object Current{get;}       //获取当前的项（只读属性）

void Reset();                 //将游标重置到第一个成员前面

}

所以，要想Garage类也可以使用foreach遍历其中的项，那我们就要修改Garage类型使之支持这些接口，可以手工实现每一个方法，不过这得花费不少功夫。虽然自己开发GetEnumerator()、MoveNext()、Current和Reset()也没有问题，但有一个更简单的办法。因为System.Array类型和其他许多类型（如List）已经实现了IEnumerable和IEnumerator接口，你可以简单委托请求到System.Array,如下所示：

1. namespace MyCarIEnumerator
2. {
3. public class Garage:IEnumerable
4. {
5. Car[] carArray = new Car[4];
6. //启动时填充一些Car对象
7. public Garage()
8. {
9. carArray[0] = new Car("Rusty", 30);
10. carArray[1] = new Car("Clunker", 50);
11. carArray[2] = new Car("Zippy", 30);
12. carArray[3] = new Car("Fred", 45);
13. }
14. public IEnumerator GetEnumerator()
15. {
16. return this.carArray.GetEnumerator();
17. }
18. }
19. }
20. //修改Garage类型之后，就可以在C#foreach结构中安全使用该类型了。

namespace MyCarIEnumerator
{
    public class Garage:IEnumerable
    {
        Car[] carArray = new Car[4];

        //启动时填充一些Car对象
        public Garage()
        {
            carArray[0] = new Car("Rusty", 30);
            carArray[1] = new Car("Clunker", 50);
            carArray[2] = new Car("Zippy", 30);
            carArray[3] = new Car("Fred", 45);
        }
        public IEnumerator GetEnumerator()
        {
            return this.carArray.GetEnumerator();
        }
    }
}
//修改Garage类型之后，就可以在C#foreach结构中安全使用该类型了。

1. //除此之外，GetEnumerator()被定义为公开的，对象用户可以与IEnumerator类型交互：
2. namespace MyCarIEnumerator
3. {
4. class Program
5. {
6. static void Main(string[] args)
7. {
8. Console.WriteLine("*********Fun with IEnumberable/IEnumerator************\n");
9. Garage carLot = new Garage();
10. //交出集合中的每一Car对象吗
11. foreach (Car c in carLot)  //之所以遍历carLot，是因为carLot.GetEnumerator()返回的项时Car类型，这个十分重要
12. {
13. Console.WriteLine("{0} is going {1} MPH", c.CarName, c.CurrentSpeed);
14. }
15. Console.WriteLine("GetEnumerator被定义为公开的，对象用户可以与IEnumerator类型交互，下面的结果与上面是一致的");
16. //手动与IEnumerator协作
17. IEnumerator i = carLot.GetEnumerator();
18. while (i.MoveNext())
19. {
20. Car myCar = (Car)i.Current;
21. Console.WriteLine("{0} is going {1} MPH", myCar.CarName, myCar.CurrentSpeed);
22. }
23. Console.ReadLine();
24. }
25. }
26. }

//除此之外，GetEnumerator()被定义为公开的，对象用户可以与IEnumerator类型交互：
namespace MyCarIEnumerator
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("*********Fun with IEnumberable/IEnumerator************\n");
            Garage carLot = new Garage();

            //交出集合中的每一Car对象吗
            foreach (Car c in carLot)  //之所以遍历carLot，是因为carLot.GetEnumerator()返回的项时Car类型，这个十分重要
            {
                Console.WriteLine("{0} is going {1} MPH", c.CarName, c.CurrentSpeed);
            }

            Console.WriteLine("GetEnumerator被定义为公开的，对象用户可以与IEnumerator类型交互，下面的结果与上面是一致的");
            //手动与IEnumerator协作
            IEnumerator i = carLot.GetEnumerator();
            while (i.MoveNext())
            {
                Car myCar = (Car)i.Current;
                Console.WriteLine("{0} is going {1} MPH", myCar.CarName, myCar.CurrentSpeed);
            }
            Console.ReadLine();
        }
    }
}

下面我们来看看手工实现IEnumberable接口和IEnumerator接口中的方法：

1. namespace ForeachTestCase
2. {
3. //继承IEnumerable接口，其实也可以不继承这个接口，只要类里面含有返回IEnumberator引用的GetEnumerator()方法即可
4. class ForeachTest:IEnumerable     {
5. private string[] elements;  //装载字符串的数组
6. private int ctr = 0;  //数组的下标计数器
7. /// <summary>
8. /// 初始化的字符串
9. /// </summary>
10. /// <param name="initialStrings"></param>
11. ForeachTest(params string[] initialStrings)
12. {
13. //为字符串分配内存空间
14. elements = new String[8];
15. //复制传递给构造方法的字符串
16. foreach (string s in initialStrings)
17. {
18. elements[ctr++] = s;
19. }
20. }
21. /// <summary>
22. ///  构造函数
23. /// </summary>
24. /// <param name="source">初始化的字符串</param>
25. /// <param name="delimiters">分隔符，可以是一个或多个字符分隔</param>
26. ForeachTest(string initialStrings, char[] delimiters)
27. {
28. elements = initialStrings.Split(delimiters);
29. }
30. //实现接口中得方法
31. public IEnumerator GetEnumerator()
32. {
33. return  new ForeachTestEnumerator(this);
34. }
35. private class ForeachTestEnumerator : IEnumerator
36. {
37. private int position = -1;
38. private ForeachTest t;
39. public ForeachTestEnumerator(ForeachTest t)
40. {
41. this.t = t;
42. }
43. #region 实现接口
44. public object Current
45. {
46. get
47. {
48. return t.elements[position];
49. }
50. }
51. public bool MoveNext()
52. {
53. if (position < t.elements.Length - 1)
54. {
55. position++;
56. return true;
57. }
58. else
59. {
60. return false;
61. }
62. }
63. public void Reset()
64. {
65. position = -1;
66. }
67. #endregion
68. }
69. static void Main(string[] args)
70. {
71. // ForeachTest f = new ForeachTest("This is a sample sentence.", new char[] { ' ', '-' });
72. ForeachTest f = new ForeachTest("This", "is", "a", "sample", "sentence.");
73. foreach (string item in f)
74. {
75. System.Console.WriteLine(item);
76. }
77. Console.ReadKey();
78. }
79. }
80. }

namespace ForeachTestCase
{
      //继承IEnumerable接口，其实也可以不继承这个接口，只要类里面含有返回IEnumberator引用的GetEnumerator()方法即可
    class ForeachTest:IEnumerable     {
        private string[] elements;  //装载字符串的数组
        private int ctr = 0;  //数组的下标计数器

        /// <summary>
        /// 初始化的字符串
        /// </summary>
        /// <param name="initialStrings"></param>
        ForeachTest(params string[] initialStrings)
        {
            //为字符串分配内存空间
            elements = new String[8];
            //复制传递给构造方法的字符串
            foreach (string s in initialStrings)
            {
                elements[ctr++] = s;
            }
        }

        /// <summary>
        ///  构造函数
        /// </summary>
        /// <param name="source">初始化的字符串</param>
        /// <param name="delimiters">分隔符，可以是一个或多个字符分隔</param>
        ForeachTest(string initialStrings, char[] delimiters)
        {
            elements = initialStrings.Split(delimiters);
        }

        //实现接口中得方法
        public IEnumerator GetEnumerator()
        {
            return  new ForeachTestEnumerator(this);
        }

        private class ForeachTestEnumerator : IEnumerator
        {
            private int position = -1;
            private ForeachTest t;
            public ForeachTestEnumerator(ForeachTest t)
            {
                this.t = t;
            }

            #region 实现接口

            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
        }
        static void Main(string[] args)
        {
            // ForeachTest f = new ForeachTest("This is a sample sentence.", new char[] { ' ', '-' });
            ForeachTest f = new ForeachTest("This", "is", "a", "sample", "sentence.");
            foreach (string item in f)
            {
                System.Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

IEnumerable<T>接口

实现了IEnmerable<T>接口的集合，是强类型的。它为子对象的迭代提供类型更加安全的方式。

1. public  class ListBoxTest:IEnumerable<String>
2. {
3. private string[] strings;
4. private int ctr = 0;
5. #region IEnumerable<string> 成员
6. //可枚举的类可以返回枚举
7. public IEnumerator<string> GetEnumerator()
8. {
9. foreach (string s in strings)
10. {
11. yield return s;
12. }
13. }
14. #endregion
15. #region IEnumerable 成员
16. //显式实现接口
17. System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
18. {
19. return GetEnumerator();
20. }
21. #endregion
22. //用字符串初始化列表框
23. public ListBoxTest(params string[] initialStrings)
24. {
25. //为字符串分配内存空间
26. strings = new String[8];
27. //复制传递给构造方法的字符串
28. foreach (string s in initialStrings)
29. {
30. strings[ctr++] = s;
31. }
32. }
33. //在列表框最后添加一个字符串
34. public void Add(string theString)
35. {
36. strings[ctr] = theString;
37. ctr++;
38. }
39. //允许数组式的访问
40. public string this[int index]
41. {
42. get {
43. if (index < 0 || index >= strings.Length)
44. {
45. //处理不良索引
46. }
47. return strings[index];
48. }
49. set {
50. strings[index] = value;
51. }
52. }
53. //发布拥有的字符串数
54. public int GetNumEntries()
55. {
56. return ctr;
57. }
58. }

 public  class ListBoxTest:IEnumerable<String>
    {
        private string[] strings;
        private int ctr = 0;

        #region IEnumerable<string> 成员
        //可枚举的类可以返回枚举
        public IEnumerator<string> GetEnumerator()
        {
            foreach (string s in strings)
            {
                yield return s;
            }
        }

        #endregion

        #region IEnumerable 成员
        //显式实现接口
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        //用字符串初始化列表框
        public ListBoxTest(params string[] initialStrings)
        {
            //为字符串分配内存空间
            strings = new String[8];
            //复制传递给构造方法的字符串
            foreach (string s in initialStrings)
            {
                strings[ctr++] = s;
            }
        }

        //在列表框最后添加一个字符串
        public void Add(string theString)
        {
            strings[ctr] = theString;
            ctr++;
        }

        //允许数组式的访问
        public string this[int index]
        {
            get {
                if (index < 0 || index >= strings.Length)
                {
                    //处理不良索引
                }
                return strings[index];
            }
            set {
                strings[index] = value;
            }
        }

        //发布拥有的字符串数
        public int GetNumEntries()
        {
            return ctr;
        }
    }

1. class Program
2. {
3. static void Main(string[] args)
4. {
5. //创建一个新的列表框并初始化
6. ListBoxTest lbt = new ListBoxTest("Hello", "World");
7. //添加新的字符串
8. lbt.Add("Who");
9. lbt.Add("Is");
10. lbt.Add("Douglas");
11. lbt.Add("Adams");
12. //测试访问
13. string subst = "Universe";
14. lbt[1] = subst;
15. //访问所有的字符串
16. foreach (string s in lbt)
17. {
18. Console.WriteLine("Value:{0}", s);
19. }
20. Console.ReadKey();
21. }
22. }

  class Program
    {
        static void Main(string[] args)
        {
            //创建一个新的列表框并初始化
            ListBoxTest lbt = new ListBoxTest("Hello", "World");

            //添加新的字符串
            lbt.Add("Who");
            lbt.Add("Is");
            lbt.Add("Douglas");
            lbt.Add("Adams");

            //测试访问
            string subst = "Universe";
            lbt[1] = subst;

            //访问所有的字符串
            foreach (string s in lbt)
            {
                Console.WriteLine("Value:{0}", s);
            }
            Console.ReadKey();
        }
    }

综上所述，一个类型是否支持foreach遍历，必须满足下面条件：

方案1：让这个类实现IEnumerable接口

方案2：这个类有一个public的GetEnumerator的实例方法，并且返回类型中有public 的bool MoveNext()实例方法和public的Current实例属性。

分享到：

• 上一篇：BindingSource控件介绍
• 下一篇：Attributes特性