C#知识点-枚举器和迭代器

一、几个基本概念的理解

问题一：为什么数组可以使用foreach输出各元素

答：数组是可枚举类型，它实现了一个枚举器(enumerator)对象；枚举器知道各元素的次序并跟踪它们的位置，然后返回请求的当前项

问题二：不用foreach能不能遍历各元素

问题三：什么是可枚举类

答：可枚举类是指实现了IEnumerable接口的类；IEnumerable接口只有一个成员GetEnumerator方法，它返回对象的枚举器

问题四：什么是枚举器

答：实现了IEnumerator接口的枚举器包含三个函数成员：Current，MoveNext，Reset

Current是只读属性，它返回object类型的引用；

MoveNext是把枚举器位置前进到集合的下一项的方法，它返回布尔值，指示新的位置是否有效位置还是已经超过了序列的尾部；

Reset是把位置重置为原始状态的方法；

二、下面代码展示了一个可枚举类的完整示例

namespace ConsoleApplication4
{
    /// <summary>
    /// 自定义一个枚举对象
    /// </summary>
    class ColorEnumerator : IEnumerator
    {
        private string[] _colors;
        private int _position = -1;

        public ColorEnumerator(string[] arr)
        {
            _colors = arr;
            for (int i = 0; i < arr.Length; i++)
            {
                _colors[i] = arr[i];
            }
        }
        public object Current
        {
            get
            {
                if (_position == -1)
                {
                    throw new InvalidOperationException();
                }
                if (_position >= _colors.Length)
                {
                    throw new InvalidOperationException();
                }
                return _colors[_position];
            }
        }

        public bool MoveNext()
        {
            if (_position < _colors.Length - 1)
            {
                _position++;
                return true;
            }
            else
            {
                return false;
            }
        }

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

    /// <summary>
    /// 创建一个实现IEnumerable接口的枚举类
    /// </summary>
    class Spectrum : IEnumerable
    {
        private string[] Colors = { "red", "yellow", "blue" };
        public IEnumerator GetEnumerator()
        {
            return new ColorEnumerator(Colors);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Spectrum spectrum = new Spectrum();
            foreach (string color in spectrum)
            {
                Console.WriteLine(color);
            }
            Console.ReadKey();
        }
    }
}

三、泛型枚举接口

IEnumerable<T>接口的GetEnumerator方法返回实现IEnumerator<T>的枚举类的实例；

实现IEnumerator<T>的类实现了Current属性，它返回实际类型的对象，而不是object基类的引用；

所以非泛型接口的实现不是类型安全的，因为还需要转换为实际类型。

四、迭代器

1.使用迭代器来创建枚举器

namespace ConsoleApplication5
{
    class MyClass
    {
        /// <summary>
        /// 获取一个迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator<string> GetEnumerator()
        {
            return ColorEnumerator();
        }
        /// <summary>
        /// 迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator<string> ColorEnumerator()
        {
            yield return "red";
            yield return "yellow";
            yield return "blue";
        } 
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            foreach (string color in mc)
            {
                Console.WriteLine(color);
            }
            Console.ReadKey();
        }
    }
}

2.使用迭代器来创建枚举类型

namespace ConsoleApplication6
{
    class MyClass
    {
        public IEnumerator<string> GetEnumerator()
        {
            //获取可枚举类型
            IEnumerable<string> enumerable = ColorEnumerable();
            //获取枚举器
            return ColorEnumerable().GetEnumerator();
        }

        public IEnumerable<string> ColorEnumerable()
        {
            yield return "red";
            yield return "yellow";
            yield return "blue";
        } 
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            //使用类对象
            foreach (string color in mc)
            {
                Console.WriteLine(color);
            }
            Console.WriteLine("-----------------------");
            //使用类枚举器的方法
            foreach (string color in mc.ColorEnumerable())
            {
                Console.WriteLine(color);
            }
            Console.ReadKey();
        }
    }
}

3.产生多个可迭代类型

namespace ConsoleApplication7
{
    class MyClass
    {
        private string[] Colors = { "red", "yellow", "blue" };
        //顺序
        public IEnumerable<string> ColorOrder()
        {
            for (int i = 0; i < Colors.Length; i++)
            {
                yield return Colors[i];
            }
        }
        //逆序
        public IEnumerable<string> ColorReversed()
        {
            for (int i = Colors.Length - 1; i >= 0; i--)
            {
                yield return Colors[i];
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            foreach (string color in mc.ColorOrder())
            {
                Console.WriteLine(color);
            }
            Console.WriteLine("------------------");
            foreach (string color in mc.ColorReversed())
            {
                Console.WriteLine(color);
            }
            Console.ReadKey();
        }
    }
}