迭代模式

不就是迭代模式吗，就是第一个，上一个，下一个，最后一个，当前元素吗？
用得着搞几个接口弄出五六个类出来吗？
而且元素还是Object类型,装箱，拆箱的，真要命，用泛型吧
有时候在想，设计模式是用来欣赏的、用来学习的，真正在用的时候根本用不上，那么多接口和类，调来调去的
不好资源的吗？真正在用的时候应该是精简版的设计模式，你也可以说他不是设计模式，毕竟嘴是你的。
如果你的方法参数为基础类型，没有用out或ref,C#就会为你产生一个变量，因为基础类型是值拷贝
当然基础类型分配在栈中，分配速度较快，而且能很快回收，栈的容量是有限的吗，能不很快回收吗。
栈是先进后出，比如一个方法中的基础类型变量，先定义的先进栈，却后释放，什么叫压栈，就是这个道理啦。
引用类型参数一般不会产生多余的变量，引用类型就是引用对象的地址，直接对对象的地址内容进行操作
引用类型分配在托管堆中，在其中分配资源的速度相对栈较慢，因为需要寻找空闲内存，搜集整理内存碎片，都是要时间的。
托管堆中的资源什么时候被GC回收是不知道的，当然不会很久，这种事情是不能拖的，他可跟控件不同，你想脱就脱啊。

namespace ClassTest
{
    /// <summary>
    /// 迭代模式
    /// </summary>
   public class Iterator<T>
    {
       private ConcreteList<T> concreteList;
       //索引值
       int index;
       public Iterator(ConcreteList<T> concreteList)
       {
           index = 0;
           this.concreteList = concreteList;
       }

       
       /// <summary>
       /// 第一个元素
       /// </summary>
       public void First()
       {
           index = 0;
       }

       
       /// <summary>
       /// 最后一个元素
       /// </summary>
       public void Last()
       {
           index = concreteList.Count - 1;
       }

        
       /// <summary>
       /// 当前元素
       /// </summary>
       /// <returns></returns>
       public T CurrentItem()
       {
           return concreteList.GetCurrent(index);
       }

        
       /// <summary>
       /// 下一个元素
       /// </summary>
       /// <returns></returns>
       public bool Next()
       {
           if (++index >= concreteList.Count) //如果当前元素已经最后一个元素，返回false
           {
               return false;
           }
           return true;
       }

      
       /// <summary>
       /// 上一个元素
       /// </summary>
       private void Previous()
       {
           if (index > 0)
           {
               index--;
           }
       }

    }
}

using System;
using System.Collections.Generic;

namespace ClassTest
{
   /// <summary>
   /// 实体集合
   /// 对元素进行添加、删除和显示
   /// </summary>
   /// <typeparam name="T"></typeparam>
   public class ConcreteList<T>
    {
       private IList<T> list;

       public ConcreteList()
       {
           list = new List<T>();
       }

 
       /// <summary>
       /// 添加元素
       /// </summary>
       /// <param name="t"></param>
       public void Add(T t)
       {
           list.Add(t);
       }

 
       /// <summary>
       /// 删除指定元素
       /// </summary>
       /// <param name="t"></param>
       public void Remove(T t)
       {
           list.Remove(t); 
       }

 
       /// <summary>
       /// 根据索引删除元素
       /// </summary>
       /// <param name="index"></param>
       public void RemoveAt(int index)
       {
           if (Count <= index)     //索引超出范围
           {
               throw new ArgumentOutOfRangeException("index");
           }
           list.RemoveAt(index);
       }

 
       /// <summary>
       /// 元素个数
       /// </summary>
       public int Count
       {
           get {
               return list.Count;
           }
       }

 
       /// <summary>
       /// 获取当前元素
       /// </summary>
       /// <param name="index"></param>
       /// <returns></returns>
       public T GetCurrent(int index)
       {
           if (Count == 0)       //处理集合为空的情况
           {
               return default(T);
           }
           if (Count<=index)     //索引超出范围
           {
               throw new ArgumentOutOfRangeException("index");
           }
           return list[index];
       }

       
    }
}