迭代器

   public abstract class Aggegate<T>
    {
        public abstract ITerator<T> GeTerator();
    }

    public class ConAggregate<T> : Aggegate<T>
    {
        public T[] Datas { set; get; }

        public override ITerator<T> GeTerator()
        {
            return new ConIterator<T>(this);
        }
    }

    public interface ITerator<out T>
    {
        void Reset();
        bool MoveNext();

        T CurrentItem { get; }
    }

    public class ConIterator<T> : ITerator<T>
    {
        private ConAggregate<T> ct;
        
        int position = -1;
        public ConIterator(ConAggregate<T> c)
        {
            ct = c;
        }

        public T CurrentItem
        {
            get { return ct.Datas[position]; }
        }

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

        public bool MoveNext()
        {
            position++;
            return position < ct.Datas.Length;
        }
    }

  public class ConAggregateYield<T>:IEnumerable
    {
        public T[] Datas { set; get; }

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