迭代器

迭代器：就是对可枚举类型的简化，实现的功能与可枚举类型是一样的，可以使foreach遍历类...只是由.net内部帮我们创建枚举数，无须手动创建.

使用迭代器的关键字：yield return--延迟注册

延迟注册也就是当编译器执行到带有yield return方法时，暂不执行该方法，等到在foreach中去执行--详情参考http://www.cnblogs.com/artech/archive/2010/10/28/yield.html

 class Program
    {
        static void Main(string[] args)
        {
            IEnumerable<Chinese> cs = GetChinese();

            foreach (Chinese c in cs)
            {
                c.Age = 1;
                Console.WriteLine(c.Age);
            }

            foreach (Chinese c in cs)
            {
                Console.WriteLine(c.Age);
            }

            Console.ReadKey();
        }

        static IEnumerable<Chinese> GetChinese()
        {
            yield return new Chinese("tom", 11);
            yield return new Chinese("jeery", 15);
            yield return new Chinese("marry", 22);
        }
    }
   

这就简单的迭代器的运用...

现在让我们重写下之前用可枚举类型和枚举数写的代码：

class Program
    {
        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 (string item in p)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }

    //那么现在假设Person类有一个记忆功能，现在我想用foreach遍历person类读取，记忆中的数据，并把数据显示出来..
//所以我先声明一个Person类，他有Name,Age,Memory字段，还有一个构造函数以及一个See方法，模拟人从外界得到记忆...
    class Person
    {
        public int Age;
        public string Name;
        List<string> memory = new List<string>();

        //外界只能读取记忆，不能设置记忆
        public string[] Memory
        {
            get
            {
                return memory.ToArray();
            }
        }

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

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

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

        //思考下为什么这里返回值不是IEnumerable？而是IEnumerator..
        public IEnumerator<string> GetEnumerator()//迭代器
        {
            foreach (string s in memory)
            {
                yield return s;
            }
        }
    }

　　运行后代码如下     

sky
ok
mother
father
good
wonderful
wather

思考下为什么这里返回值不是IEnumerable？而是IEnumerator..

如果IEnumerable的话，这里就不能直接foreach (string item inp)，而应该是foreach (string item inp.GetEnumerator())，为什么？在可枚举类型中，要使一个类可枚举，就必须使类实现IEnumerable接口，而该接口中有且只有一个方法GetEnumerator，而迭代器仅仅只是对对可枚举类型的简化，所以如果类中有GetEnumerator方法，.net会默认调用，当然前提是该方法的返回值要跟IEnumerable的接口方法的返回值一样...