C#学习笔记（二十三）枚举数和可枚举类型

1. IEnumerator接口

    IEnumerator接口包含3个函数成员：Current、MoveNext以及Reset

• Current返回序列中当前位置项的属性。

    它是只读属性。
    它返回object类型的引用，所以可以返回任何类型。

• MoveNext是把枚举数位置前进到集合中下一项的方法。

    如果有新的位置是有效的，方法返回true。
    如果新的位置是无效的，方法返回false。
    枚举数的原始位置在序列中的第一项之前。MoveNext必须在第一次使用Current之前使用。

• Reset方法把位置重置为原始状态。

    class Program
    { 
        static void Main(string[] args)
        {
            int[] array = new int[6] { 1, 2, 3, 4, 5, 7 };

            IEnumerator enumerator = array.GetEnumerator();

            //将枚举数推进到集合的下一个元素。
            //返回结果：如果枚举数已成功地推进到下一个元素，则为 true；如果枚举数传递到集合的末尾，则为 false。
            while (enumerator.MoveNext())
            {
                //获取集合中位于枚举数当前位置的元素。
                //返回结果：集合中位于枚举数当前位置的元素。
                Console.WriteLine(enumerator.Current);
            }

            Console.ReadKey();
        }      
    }

     2.IEnumerable接口

     IEnumerable接口只含有一个函数成员：GetEnumerable

     GetEnumerable返回对象的枚举数

    class Number : IEnumerator
    {
        private int index = -1;
        private readonly int[] number;

        public Number(int[] param)
        {
            number = param;
        }

        public object Current
        {
            get
            {
                if (index == -1)
                {
                    throw new IndexOutOfRangeException();
                }
                else if (index == number.Length)
                {
                    throw new IndexOutOfRangeException();
                }
                else
                {
                    return number[index];
                }

            }
        }


        bool IEnumerator.MoveNext()
        {
            if (index < number.Length - 1)
            {
                index++;
                return true;
            }
            else
            {
                return false;
            }
        }

        void IEnumerator.Reset()
        {
            index = -1;
        }
    }

    class GetNumber : IEnumerable
    {
        readonly int[] array = new int[6] { 1, 2, 3, 4, 5, 7 };

        public IEnumerator GetEnumerator()
        {
            Number number = new Number(array);
            return number;
        }
    }

    class Program
    { 
        static void Main(string[] args)
        {
            GetNumber getNumber = new GetNumber();
            foreach (int number in getNumber)
            {
                Console.WriteLine(number);
            }

            Console.ReadKey();
        }      
    }

3.IEnumerator<T>接口
IEnumerator<T>接口使用泛型来返回实际的类型，而不是object类型的引用。
IEnumerator<T>接口从另外两个接口继承-IEnumerator接口和IDisposable接口。
IEnumerator<T>接口本身只有一个Current的成员，其他的成员都是实现其继承的另外的两个接口。

4.IEnumerable<T>接口
IEnumerable<T>接口继承自IEnumerable接口。
IEnumerable<T>接口有俩个GetEnumerable成员，一个是自身接口的成员，一个是实现IEnumerable接口的成员。

    //通过使用泛型接口，可以避免值类型的拆箱和装箱的过程，
    //也避免了object转换时可能发生的类型异常
    public class Number : IEnumerator<int>
    {
        private int index = -1;
        private readonly int[] number;

        public Number(int[] param)
        {
            number = param;
        }

        object IEnumerator.Current
        {
            get
            {
                if (index == -1)
                {
                    throw new IndexOutOfRangeException();
                }
                else if (index == number.Length)
                {
                    throw new IndexOutOfRangeException();
                }
                else
                {
                    return number[index];
                }

            }
        }
        public int Current
        {
            get
            {
                if (index == -1)
                {
                    throw new IndexOutOfRangeException();
                }
                else if (index == number.Length)
                {
                    throw new IndexOutOfRangeException();
                }
                else
                {
                    return number[index];
                }

            }
        }

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

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

        #region IDisposable Support
        private bool disposedValue = false; // 要检测冗余调用

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: 释放托管状态(托管对象)。
                }

                // TODO: 释放未托管的资源(未托管的对象)并在以下内容中替代终结器。
                // TODO: 将大型字段设置为 null。

                disposedValue = true;
            }
        }


        // 添加此代码以正确实现可处置模式。
        public void Dispose()
        {
            // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
            Dispose(true);
            // TODO: 如果在以上内容中替代了终结器，则取消注释以下行。
            // GC.SuppressFinalize(this);
        }
        #endregion
    }

    class GetNumber : IEnumerable<int>
    {
        readonly int[] array = new int[6] { 1, 2, 3, 4, 5, 7 };

        public IEnumerator<int> GetEnumerator()
        {
            Number number = new Number(array);
            return number;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            Number number = new Number(array);
            return number;
        }
    }

    class Program
    { 
        static void Main(string[] args)
        {
            GetNumber getNumber = new GetNumber();
            foreach (int number in getNumber)
            {
                Console.WriteLine(number);
            }

            Console.ReadKey();
        }      
    }