CSharp: Iterator Pattern in donet core 3

 

    #region Iterator

    /// <summary>
    /// 迭代器模式 Iterator Pattern
    /// geovindu,Geovin Du edit
    /// </summary>
    public interface IIterator
    {
        /// <summary>
        /// Reset to first element
        /// 第一
        /// </summary>

        void First();
        /// <summary>
        /// Get next element
        /// 下一个
        /// </summary>
        /// <returns></returns>
        string Next();
        /// <summary>
        /// End of collection check
        /// 是否最生
        /// </summary>
        /// <returns></returns>
        bool IsCollectionEnds();
        /// <summary>
        /// Retrieve Current Item
        /// 是否当前
        /// </summary>
        /// <returns></returns>
        string CurrentItem();
    }

    /// <summary>
    ///  Science Iterator
    ///  科学
    /// </summary>
    public class ScienceIterator : IIterator
    {
        /// <summary>
        /// 科目列表
        /// </summary>
        private LinkedList<string> Subjects;
        /// <summary>
        /// 位置
        /// </summary>
        private int position;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="subjects">输入科目列表</param>
        public ScienceIterator(LinkedList<string> subjects)
        {
            this.Subjects = subjects;
            position = 0;
        }
        /// <summary>
        /// 第一个位置，0开始
        /// </summary>
        public void First()
        {
            position = 0;
        }
        /// <summary>
        /// 下一个位置，加1
        /// </summary>
        /// <returns></returns>
        public string Next()
        {
            return Subjects.ElementAt(position++);
        }
        /// <summary>
        /// 是否最后
        /// </summary>
        /// <returns></returns>
        public bool IsCollectionEnds()
        {
            if (position < Subjects.Count)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 当前目录
        /// </summary>
        /// <returns></returns>
        public string CurrentItem()
        {
            return Subjects.ElementAt(position);
        }
    }
    /// <summary>
    ///  Arts Iterator
    ///  行为艺术
    /// </summary>
    public class ArtsIterator : IIterator
    {
        /// <summary>
        /// 科目列表
        /// </summary>
        private string[] Subjects;
        /// <summary>
        /// 位置位
        /// </summary>
        private int position;
        /// <summary>
        /// 行位艺术构造对象
        /// </summary>
        /// <param name="subjects">输入科目列表</param>
        public ArtsIterator(string[] subjects)
        {
            this.Subjects = subjects;
            position = 0;
        }
        /// <summary>
        /// 第一
        /// </summary>
        public void First()
        {
            position = 0;
        }
        /// <summary>
        /// 下一个
        /// </summary>
        /// <returns></returns>
        public string Next()
        {
            //Console.WriteLine("Currently pointing to the subject: "+ this.CurrentItem());
            return Subjects[position++];
        }
        /// <summary>
        /// 是否最后
        /// </summary>
        /// <returns></returns>
        public bool IsCollectionEnds()
        {
            if (position >= Subjects.Length)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 当前
        /// </summary>
        /// <returns></returns>
        public string CurrentItem()
        {
            return Subjects[position];
        }
    }
    #endregion

    #region Aggregate
    /// <summary>
    /// 
    /// </summary>
    public interface ISubjects
    {
        IIterator CreateIterator();
    }
    /// <summary>
    /// 科学
    /// </summary>
    public class Science : ISubjects
    {
        /// <summary>
        /// 科目列表
        /// </summary>
        private LinkedList<string> Subjects;
        /// <summary>
        /// 科学构造对象方法
        /// 
        /// </summary>
        public Science()
        {
            Subjects = new LinkedList<string>();
            Subjects.AddFirst("Mathematics 应用数学");
            Subjects.AddFirst("Computer Science计算机科学");
            Subjects.AddFirst("Physics物理学");
            Subjects.AddFirst("Electronics电子学");
        }
        /// <summary>
        /// 创建对象
        /// </summary>
        /// <returns></returns>
        public IIterator CreateIterator()
        {
            return new ScienceIterator(Subjects);
        }
    }
    /// <summary>
    /// 行为艺术
    /// </summary>
    public class Arts : ISubjects
    {
        /// <summary>
        /// 科目列表
        /// </summary>
        private string[] Subjects;
        /// <summary>
        /// 构造行为艺术对象
        /// </summary>
        public Arts()
        {
            Subjects = new[] { "English英语", "History历史", "Geography地理", "Psychology心理学" };
        }
        /// <summary>
        /// 创建一个对象方法
        /// </summary>
        /// <returns></returns>
        public IIterator CreateIterator()
        {
            return new ArtsIterator(Subjects);
        }
    }
    #endregion

　　

  /// <summary>
    /// 迭代器模式 Iterator Pattern
    /// geovindu,Geovin Du edit
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Node<T>
    {
        /// <summary>
        /// 
        /// </summary>
        /// 
        public T Value;
        /// <summary>
        /// 
        /// </summary>
        public Node<T> Left, Right;
        /// <summary>
        /// 
        /// </summary>
        public Node<T> Parent;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        public Node(T value)
        {
            Value = value;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        public Node(T value, Node<T> left, Node<T> right)
        {
            Value = value;
            Left = left;
            Right = right;

            left.Parent = right.Parent = this;
        }
    }
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class InOrderIterator<T>
    {

        /// <summary>
        /// 
        /// </summary>
        public Node<T> Current { get; set; }
        /// <summary>
        /// 
        /// </summary>
        private readonly Node<T> root;
        /// <summary>
        /// 
        /// </summary>
        private bool yieldedStart;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="root"></param>
        public InOrderIterator(Node<T> root)
        {
            this.root = Current = root;
            while (Current.Left != null)
                Current = Current.Left;
        }
        /// <summary>
        /// 
        /// </summary>
        public void Reset()
        {
            Current = root;
            yieldedStart = true;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool MoveNext()
        {
            if (!yieldedStart)
            {
                yieldedStart = true;
                return true;
            }

            if (Current.Right != null)
            {
                Current = Current.Right;
                while (Current.Left != null)
                    Current = Current.Left;
                return true;
            }
            else
            {
                var p = Current.Parent;
                while (p != null && Current == p.Right)
                {
                    Current = p;
                    p = p.Parent;
                }
                Current = p;
                return Current != null;
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class BinaryTree<T>
    {

        /// <summary>
        /// 
        /// </summary>
        private Node<T> root;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="root"></param>
        public BinaryTree(Node<T> root)
        {
            this.root = root;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public InOrderIterator<T> GetEnumerator()
        {
            return new InOrderIterator<T>(root);
        }
        /// <summary>
        /// 
        /// </summary>
        public IEnumerable<Node<T>> NaturalInOrder
        {
            get
            {
                IEnumerable<Node<T>> TraverseInOrder(Node<T> current)
                {
                    if (current.Left != null)
                    {
                        foreach (var left in TraverseInOrder(current.Left))
                            yield return left;
                    }
                    yield return current;
                    if (current.Right != null)
                    {
                        foreach (var right in TraverseInOrder(current.Right))
                            yield return right;
                    }
                }
                foreach (var node in TraverseInOrder(root))
                    yield return node;
            }
        }
    }

　　

    /// <summary>
    /// 迭代器模式 Iterator Pattern
    /// geovindu,Geovin Du edit
    /// </summary>
    public static class GeovinDuPrint
    {

        /// <summary>
        /// 打印
        /// </summary>
        /// <param name="iterator"></param>
        public static void Print(IIterator iterator)
        {
            while (!iterator.IsCollectionEnds())
            {
                Console.WriteLine(iterator.Next());
            }
        }
    }

　　

 

调用：

 

            Console.WriteLine("***迭代器模式  Iterator Pattern Demonstration.***");
            //For Science
            ISubjects subjects= new Science();
            IIterator iterator = subjects.CreateIterator();
            Console.WriteLine("\nScience subjects科学课程： :");
            GeovinDuPrint.Print(iterator);

            //For Arts
            subjects = new Arts();            
            iterator = subjects.CreateIterator();
            Console.WriteLine("\nArts subjects 艺术课程:");
            GeovinDuPrint.Print(iterator);
            Console.WriteLine();


            //
            var root = new Node<int>(1,
        new Node<int>(2), new Node<int>(3));

            // C++ style
            var it = new InOrderIterator<int>(root);

            while (it.MoveNext())
            {
                Console.WriteLine(it.Current.Value);
                Console.WriteLine(',');
            }
            Console.WriteLine();

            // C# style
            var tree = new BinaryTree<int>(root);

            Console.WriteLine(string.Join(",", tree.NaturalInOrder.Select(x => x.Value)));

            // duck typing!
            foreach (var node in tree)
                Console.WriteLine(node.Value);


            Console.ReadLine();

　　

输出：

***迭代器模式  Iterator Pattern Demonstration.***

Science subjects科学课程： :
Electronics电子学
Physics物理学
Computer Science计算机科学
Mathematics 应用数学

Arts subjects 艺术课程:
English英语
History历史
Geography地理
Psychology心理学

2
,
1
,
3
,

2,1,3
2
1
3