Implementation of C iterator

1. Code

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

namespace Lesson23_Iterator
{
    
    class Program
    {
    
        #region  One 、 What is an iterator 
        //  Iterator pattern   Provide a method to sequentially access   The elements 
        //  have access to foreach Traversal class , All implement iterators 
        #endregion

        #region  Two 、 What does a standard iterator need to implement 
        //  Key interfaces ：IEnumerable,
        //  Namespace ：using System.Collections;

        class MyList : IEnumerable, IEnumerator
        {
    
            private int[] list;
            private int cursor = -1;
            public MyList()
            {
    
                list = new int[] {
     1, 2, 3, 4};
            }

            // foreach  The essence 
            // 1. call  GetEnumerator  Method   obtain 
            // 2. call  MoveNext()
            // 3.MoveNext()  return true  Get  Current
            //  Again MoveNext()
            //  If you return  False  end   And call  Reset()

            #region IEnumerable

            public IEnumerator GetEnumerator()
            {
    
                //  First cursor position 
                Reset();
                //  Return your own object 
                return this;
            }
            #endregion

            #region IEnumerator
            //  return   Aggregating   object 
            public object Current 
            {
    
                get 
                {
    
                    return list[cursor];
                }
            }

            //  Move the cursor 
            public bool MoveNext()
            {
    
                //  Move the cursor 
                ++cursor;
                //  Overflow is illegal 
                return cursor < list.Length;
            }

            //  Reset cursor 
            public void Reset()
            {
    
                cursor=-1;
            }
            #endregion
        }

        #endregion

        #region  3、 ... and 、 Use yield return  Implementation iterator 
        // 1. Inherit  IEnumerable  An interface 
        // 2.  Use  yield return  return item that will do 

        class CustomList : IEnumerable
        {
    
            private int[] list;

            public CustomList()
            {
    
                this.list = new int[] {
    5, 6, 7, 8 };
            }

            public IEnumerator GetEnumerator()
            {
    
                for (int i = 0; i < list.Length; i++)
                {
    
                    //  Grammatical sugar   The specific implementation after compilation is   The traditional way 
                    yield return this.list[i];
                }
            }
        }

        #region  Four 、 Generic iterator 
        // 1. Inherit  IEnumerable  An interface 
        // 2.  Use  yield return  return item that will do 

        class TempleList<T> : IEnumerable
        {
    
            private T[] arry;

            public TempleList(params T[] arry)
            {
    
                this.arry = arry;
            }

            public IEnumerator GetEnumerator()
            {
    
                for (int i = 0; i < this.arry.Length; i++)
                {
    
                    yield return this.arry[i];
                }
            }
        }

        #endregion


        #endregion

        static void Main(string[] args)
        {
    
            Console.WriteLine("========= iterator ===========");

            MyList mylist = new MyList();

            Console.WriteLine("=========1. Traditional realization ===========");
            foreach (int item in mylist)
            {
    
                Console.WriteLine(item);
            }

            Console.WriteLine("=========2.yield  Realization ===========");

            CustomList customList = new CustomList();
            foreach (int item in customList)
            {
    
                Console.WriteLine(item);
            }
            Console.WriteLine("=========3.yield  Implement generic iterators ===========");

            TempleList<string> tempList = new TempleList<string>("AAA", "BBB", "CCC");
            foreach (var item in tempList)
            {
    
                Console.WriteLine(item);
            }

            //  summary 
            //  An iterator is   You can go directly through  foreach  Traversing objects , Without knowing the internal results 
            //  The main implementation methods are ：
            // 1. traditional method   Inherit two interfaces IEnumerable, IEnumerator
            // 2.yield return  How to achieve   Inherit  IEnumerable
            Console.ReadLine();
        }
    }
}