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();
        }
    }
}