C# 枚举集合

枚举集合指的是，对一个集合中的元素，一次列举出来。

对于数组来说，用for循环和foreach可以实现。foreach能实现，是因为继承了IEnumerator

对于一些自定义的结构，需要手动去写。

这是继承自IEnumerator，

 class TreeEnumerator<TItem>:IEnumerator<TItem> where TItem:IComparable<TItem>
    {
        private Tree<TItem> currentData = null;//二叉树类的引用
        private TItem currentItem = default(TItem);//一个泛型数据，获取当前数的结点值
        private Queue<TItem> enumDada = null;//泛型队列
        public TreeEnumerator(Tree <TItem> data)
        {
            this.currentData = data;
        }
        private void populate(Queue<TItem> enumQueue,Tree<TItem> tree)
        {
            if (tree.LeftTree != null)
            {
                populate(enumQueue, tree.LeftTree);
            }
            enumQueue.Enqueue(tree.NodeData);
            if (tree.RightTree != null)
            {
                populate(enumQueue, tree.RightTree);
            }
        }
        bool System.Collections.IEnumerator.MoveNext()//获取下一个结点的值
        {
            if (this.enumDada == null)
            {
                this.enumDada = new Queue<TItem>();
                populate(this.enumDada, this.currentData);
            }
            if (this.enumDada.Count > 0)
            {
                this.currentItem = this.enumDada.Dequeue();
                return true;
            }
            return false;
        }
        TItem IEnumerator<TItem>.Current
        {
            get
            {
                if (this.enumDada == null)
                {
                    throw new InvalidOperationException("Use MoveNext before calling Current");
                }
                return this.currentItem;
            }
        }
        void IDisposable.Dispose()
        { 
            
        }

        object System.Collections.IEnumerator.Current
        {
            get { throw new NotImplementedException(); }
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }
    }

 public class Tree<TItem> :IEnumerable<TItem> where TItem:IComparable<TItem>
    {
        public TItem NodeData { get; set; }
        public Tree<TItem> LeftTree { get; set; }
        public Tree<TItem> RightTree { get; set; }
        public Tree(TItem nodeValue)
        {
            this.NodeData = nodeValue;
            this.LeftTree = null;
            this.RightTree = null;
        }
        public void Insert(TItem newItem )
        {
            TItem currentNodeValue = this.NodeData;
            if (currentNodeValue.CompareTo(newItem) > 0)
            {
                if (LeftTree == null)
                {
                    this.LeftTree = new Tree<TItem>(newItem);
                }
                else
                {
                    this.LeftTree.Insert(newItem);
                }
            }
            else
            {
                if (RightTree == null)
                {
                    this.RightTree = new Tree<TItem>(newItem);
                }
                else
                {
                    this.RightTree.Insert(newItem);
                }
            }
        }
        IEnumerator<TItem> IEnumerable<TItem>.GetEnumerator()
        {
            return new TreeEnumerator<TItem>(this);
        }


        public void WalkTree()
        {
            if (this.LeftTree != null)
            {
                LeftTree.WalkTree();
            }
            Console.WriteLine(this.NodeData.ToString());
            if (this.RightTree != null)
            {
                RightTree.WalkTree();
            }
        }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }

 static void Main(string[] args)
        {
            Tree<int> t = new Tree<int>(10);
            t.Insert(4);
            t.Insert(3);
            t.Insert(5);
            t.Insert(14);
            t.Insert(25);
            //   t.WalkTree();
            foreach (int i in t)//这样就可以用foreach去遍历这个二叉树了
            {
                Console.WriteLine(i);
            }
        }