IEnumerable和IEnumerator，自定义实现可枚举类

//IEnumerable是一个可枚举类
并且返回String类型的枚举类IEnumerator

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace foreachTest
{
   
   
        //继承IEnumerable接口，其实也可以不继承这个接口，只要类里面含有返回IEnumberator引用的GetEnumerator()方法即可
        class ForeachTest : IEnumerable
        {
            private string[] elements;  //装载字符串的数组
            private int ctr = 0;  //数组的下标计数器

            /// <summary>
            /// 初始化的字符串
            /// </summary>
            /// <param name="initialStrings"></param>
            ForeachTest(params string[] initialStrings)
            {
                //为字符串分配内存空间
                elements = new String[8];
                //复制传递给构造方法的字符串
                foreach (string s in initialStrings)
                {
                    elements[ctr++] = s;
                }
            }

            /// <summary>
            ///  构造函数
            /// </summary>
            /// <param name="source">初始化的字符串</param>
            /// <param name="delimiters">分隔符，可以是一个或多个字符分隔</param>
            ForeachTest(string initialStrings, char[] delimiters)
            {
                elements = initialStrings.Split(delimiters);
            }

            //实现接口中得方法
            public IEnumerator GetEnumerator()
            {
                return new ForeachTestEnumerator(this);
            }

            private class ForeachTestEnumerator : IEnumerator
            {
                private int position = -1;
                private ForeachTest t;
                public ForeachTestEnumerator(ForeachTest t)
                {
                    this.t = t;
                }

                #region 实现接口

                public object Current
                {
                    get
                    {
                        return t.elements[position];
                    }
                }

                public bool MoveNext()
                {
                    if (position < t.elements.Length - 1)
                    {
                        position++;
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }

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

                #endregion
            }
            static void Main(string[] args)
            {
                // ForeachTest f = new ForeachTest("This is a sample sentence.", new char[] { ' ', '-' });
                ForeachTest f = new ForeachTest("This", "is", "a", "sample", "sentence.");
                foreach (string item in f)
                {
                    System.Console.WriteLine(item);
                }

            //创建一个新的列表框并初始化
            ListBoxTest lbt = new ListBoxTest("Hello", "World");

            //添加新的字符串
            lbt.Add("Who");
            lbt.Add("Is");
            lbt.Add("Douglas");
            lbt.Add("Adams");

            //测试访问
            string subst = "Universe";
            lbt[1] = subst;

            //访问所有的字符串
            foreach (string s in lbt)
            {
                Console.WriteLine("Value:{0}", s);
            }
            Console.ReadKey();


            }
        }
//IEnumerable<String>是一个可枚举并且返回String类型的类
    public class ListBoxTest : IEnumerable<String>
    {
        private string[] strings;
        private int ctr = 0;

        #region IEnumerable<string> 成员
        //可枚举的类可以返回枚举
        public IEnumerator<string> GetEnumerator()
        {
            foreach (string s in strings)
            {
                yield return s;
            }
        }

        #endregion

        #region IEnumerable 成员
        //显式实现接口
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        //用字符串初始化列表框
        public ListBoxTest(params string[] initialStrings)
        {
            //为字符串分配内存空间
            strings = new String[8];
            //复制传递给构造方法的字符串
            foreach (string s in initialStrings)
            {
                strings[ctr++] = s;
            }
        }

        //在列表框最后添加一个字符串
        public void Add(string theString)
        {
            strings[ctr] = theString;
            ctr++;
        }

        //允许数组式的访问
        public string this[int index]
        {
            get
            {
                if (index < 0 || index >= strings.Length)
                {
                    //处理不良索引
                }
                return strings[index];
            }
            set
            {
                strings[index] = value;
            }
        }

        //发布拥有的字符串数
        public int GetNumEntries()
        {
            return ctr;
        }
    }


    }