要使用foreach遍历类，必须让类实现IEnumerable接口，并且创建一个继承了Enumerator的类接收IEnumerable接口中GetEnumerator()方法的返回值.

那为什么数组可以直接用foreach遍历其中的数组的项呢？
因为在声明数组时.net已经隐式的让数组继承了IEnumertabel接口，并且创建了一个继承了IEnumramertor接口的类.（猜想）

那么现在假设Person类有一个记忆功能，现在我想用foreach遍历person类读取，记忆中的数据，并把数据显示出来..
所以我先声明一个Person类，他有Name,Age,Memory字段，还有一个构造函数以及一个See方法，模拟人从外界得到记忆，并实现了IEnumerable接口,now,let us begin...

class Person
    {
        private string name;
        private int age;
        private List<string> memory = new List<string>();
        public string Name
        {
            get
            {
                return name;
            }
        }

        public int Age
        {
            get
            {
                return age;
            }
        }

        public string[] Memory
        {
            get
            {
                return memory.ToArray();
            }
        }

        public Person(string name, int age)
        {
            this.name = name;
            this.age = age;
        }

        public void See(string data)
        {
            memory.Add(data);
        }

        public void See(string[] data)
        {
            memory.AddRange(data);
        }
    }

 //现在如果我们要直接遍历p中的记忆并等到他的记忆，是没有办法的。

 static void Main(string[] args)
        {
            //假设这些就是外界记忆
            string[] data = { "sky", "ok", "mother", "father", "good", "wonderful" };
            Person p = new Person("tom", 18);
        
            //将p记住了很多单词
            p.See(data);
        //p在又一次记住了一个新的单词
            p.See("wather");
            //现在如果我们先要直接遍历p中的记忆并等到他的记忆，是没有办法的。
           
            foreach (string item in p)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }

上面的代码会报错:

错误 1 “枚举数和迭代器.Person”不包含“GetEnumerator”的公共定义，因此 foreach 语句不能作用于“枚举数和迭代器.Person”类型的变量 C:\Users\Administrator.think-THINK\Documents\Visual Studio 2008\Projects\c sharp图解教程\枚举数和迭代器\Program.cs 30 13 枚举数和迭代器

 

所以我们要让Person类实现IEnumerable接口，IEnumerable接口中有且只有一个GetEnumerator方法，该方法返回IEnumerator类型参数，所以我们要创建了一个继承了IEnumramertor接口的类.用来接收GetEnumerator方放得返回值.

 

class Person:IEnumerable
    {
        private string name;
        private int age;
        private List<string> memory = new List<string>();
        public string Name
        {
            get
            {
                return name;
            }
        }

        public int Age
        {
            get
            {
                return age;
            }
        }

        public string[] Memory
        {
            get
            {
                return memory.ToArray();
            }
        }

        public Person(string name, int age)
        {
            this.name = name;
            this.age = age;
        }

        public void See(string data)
        {
            memory.Add(data);
        }

        public void See(string[] data)
        {
            memory.AddRange(data);
        }

        public IEnumerator GetEnumerator()
        {
            return new PersonEnumerator(memory);
        }
    }

    class PersonEnumerator : IEnumerator
    {
        List<string> data = new List<string>();
        public PersonEnumerator(List<string> list)
        {
            data = list;
        }
        private int positon = -1;
        public object Current
        {
            get
            {
                return data[positon];
            }
        }

        public bool MoveNext()
        {
            positon++;
            return positon < data.Count;
        }

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

在此运行代码

static void Main(string[] args)
        {
            //假设这些就是外界记忆
            string[] data = { "sky", "ok", "mother", "father", "good", "wonderful" };
            Person p = new Person("tom", 18);
        
            //将p记住了很多单词
            p.See(data);
        //p在又一次记住了一个新的单词
            p.See("wather");
            //现在可行了，因为我们Person实现了IEnumerable接口，并且创建了一个用于接收IEnumramerable方法的继承IEnumerator的类
           
            foreach (string item in p)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }

为什么数组可以直接用foreach遍历其中的item呢？
因为在声明数组时.net已经隐式的让数组继承了IEnumertabel接口，并且创建了一个继承了IEnumramertor接口的类.（猜想）

现在我们来模拟下foreach是如何工作的

static void Main(string[] args)
        {
            
            string[] data = { "sky", "ok", "mother", "father", "good", "wonderful" };
            Person p = new Person("tom", 18);
            p.See(data);
            p.See("wather");
            
            //现在让我们模拟foreach是如何工作的

            IEnumerable ieble = (IEnumerable)p;
            IEnumerator itor = ieble.GetEnumerator();

            while (itor.MoveNext())
            {
                string item = (string)itor.Current;
                Console.WriteLine(item);
            }
            

            Console.ReadKey();
        }

结果跟上面的一样。。

完全的代码如下：

View Code 
  1 static void Main(string[] args)
  2         {
  3             
  4             string[] data = { "sky", "ok", "mother", "father", "good", "wonderful" };
  5             Person p = new Person("tom", 18);
  6             p.See(data);
  7             p.See("wather");
  8             //现在如果我们先要直接遍历p中的记忆并等到他的记忆，是没有办法的。
  9 //所以我们让person实现了Ienumrabel接口，并且创建一个继承了IEnumerator接口的类来接收IEnumerable方法的返回值，因此我们终于可以用foreach遍历p，得到p 的记忆
 10 //为什么数组可以直接用foreach遍历其中的item呢？
 11 //因为在声明数组时.net已经隐式的为数组让数组继承了IEnumertabel接口，并且创建了一个继承了IEnumramertor接口的类.
 12             foreach (string item in p)
 13             {
 14                 Console.WriteLine(item);
 15             }
 16 
 17             //现在让我们模拟foreach是如何工作的
 18 　　　　　　　//其实这里利用了多态的性质，因为Person继承了IEnumerable接口，所以可以通过接口变量来调用GetEnumerator()方法，这是有理由的...foreach不可能知道你传递过来的是数据是什么类型的，如果你直接用Person来调用，那下次传递过来的是Dog类.那foreach就不能工作了
 19             IEnumerable ieble = (IEnumerable)p;
 20 　　　　　　　//为什么不用这个的原因，如上..
 21 　　　　　　　//p.GetEnumerator();
 22             IEnumerator itor = ieble.GetEnumerator();//这里也利用了多态，为什么不用PersonEnumerator，而用接口变量，理由是一样的...
 23 
 24             while (itor.MoveNext())
 25             {
 26                 string item = (string)itor.Current;
 27                 Console.WriteLine(item);
 28             }
 29             
 30 
 31             Console.ReadKey();
 32         }
 33     }
 34     //那么现在假设Person类有一个记忆功能，现在我想用foreach遍历person类读取，记忆中的数据，并把数据显示出来..
 35 //所以我先声明一个Person类，他有Name,Age,Memory字段，还有一个构造函数以及一个See方法，模拟人从外界得到记忆，并实现了IEnumerable接口,now,let us begin...
 36 
 37     class Person:IEnumerable
 38     {
 39         private string name;
 40         private int age;
 41         private List<string> memory = new List<string>();
 42         public string Name
 43         {
 44             get
 45             {
 46                 return name;
 47             }
 48         }
 49 
 50         public int Age
 51         {
 52             get
 53             {
 54                 return age;
 55             }
 56         }
 57 
 58         public string[] Memory
 59         {
 60             get
 61             {
 62                 return memory.ToArray();
 63             }
 64         }
 65 
 66         public Person(string name, int age)
 67         {
 68             this.name = name;
 69             this.age = age;
 70         }
 71 
 72         public void See(string data)
 73         {
 74             memory.Add(data);
 75         }
 76 
 77         public void See(string[] data)
 78         {
 79             memory.AddRange(data);
 80         }
 81 
 82         public IEnumerator GetEnumerator()
 83         {
 84             return new PersonEnumerator(memory);
 85         }
 86     }
 87 
 88     class PersonEnumerator : IEnumerator
 89     {
 90         List<string> data = new List<string>();
 91         public PersonEnumerator(List<string> list)
 92         {
 93             data = list;
 94         }
 95         private int positon = -1;
 96         public object Current
 97         {
 98             get
 99             {
100                 return data[positon];
101             }
102         }
103 
104         public bool MoveNext()
105         {
106             positon++;
107             return positon < data.Count;
108         }
109 
110         public void Reset()
111         {
112             positon = -1;
113         }
114     }