21_迭代器模式

迭代器模式是一种行为型设计模式，它提供了一种统一的方式来访问集合对象中的元素，而不需要暴露集合对象的内部结构。迭代器模式将遍历操作封装在迭代器对象中，使得客户端可以通过迭代器对象依次访问集合中的元素。

迭代器模式有三个主要角色：

1. 迭代器（Iterator）：定义了访问和遍历集合对象的接口，包含用于获取下一个元素、判断是否还有元素的方法等。

2. 具体迭代器（Concrete Iterator）：实现了迭代器接口，并提供了具体的遍历集合的逻辑。具体迭代器可以追踪集合中当前元素的位置。

3. 集合（Collection）：定义了创建迭代器对象的接口，通常包含一个返回迭代器的方法。

4. 具体集合（Concrete Collection）：实现了集合接口，并提供了具体的创建迭代器对象的方法。

迭代器模式的工作原理如下：

1. 客户端通过集合对象获取迭代器对象。

2. 客户端使用迭代器对象来访问和遍历集合中的元素。

3. 迭代器对象通过内部状态来追踪当前访问的元素，提供了获取下一个元素的方法，并可以判断是否还有元素。

迭代器模式的优点包括：

1. 将遍历集合的操作封装在迭代器对象中，使得客户端可以独立于集合对象进行遍历。

2. 提供了一种统一的方式来访问集合中的元素，而不需要暴露集合的内部结构。

3. 支持多种不同的遍历方式，客户端可以根据需要选择合适的迭代器对象。

迭代器模式适用于以下场景：

1. 当需要遍历集合对象的元素，但不希望暴露集合对象的内部结构时，可以使用迭代器模式。

2. 当需要支持多种不同的遍历方式，或者需要遍历不同类型的集合对象时，可以使用迭代器模式。

总结而言，迭代器模式通过封装遍历集合的操作在迭代器对象中，使得客户端可以独立于集合对象进行遍历。它提供了一种统一的方式来访问集合中的元素，而不需要暴露集合的内部结构。迭代器模式可以支持多种不同的遍历方式，并且可以适用于不同类型的集合对象。

Iterator

/// <summary>
    /// 迭代器接口
    /// </summary>
    public interface IIterator<T>
    {
        /// <summary>
        /// 获取对象
        /// </summary>
        /// <returns></returns>
        T Next();

        /// <summary>
        /// 判断是否有下一个对象
        /// </summary>
        /// <returns></returns>
        bool HasNext();
    }

 Collection

/// <summary>
    /// 集合接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public  interface  IAggregate<T>
    {
        /// <summary>
        /// 建造
        /// </summary>
        /// <returns></returns>
        IIterator<T> Create();
    }

Concrete Iterator

/// <summary>
    /// 具体迭代器
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConcreteIterator<T> : IIterator<T>
    {
        private readonly List<T> _list;//集合
        private int _index;//下标

        public ConcreteIterator(List<T> list)
        {
            _list = list;
        }   

        public bool HasNext()
        {
            return _index < _list.Count;
        }

        public T Next()
        {
            T result=default(T);
            if(HasNext())
            {
                result = _list[_index++];
            }
            return result;
        }
    }

 Concrete Collection

/// <summary>
    /// 具体集合类
    /// </summary>
    public class ConcreteAggregate<T> : IAggregate<T>
    {
        private readonly List<T> _list;

        public ConcreteAggregate()
        {
            _list = new List<T>();
        }

        public void Add(T item)
        {
            _list.Add(item);
        }

        public IIterator<T> Create()
        {
            return new ConcreteIterator<T>(_list);
        }
    }

 调用

public class Client
    {
        public void Start()
        {
            ConcreteAggregate<string> aggregate = new ConcreteAggregate<string>();
            aggregate.Add("AAAAAAAAAAA");
            aggregate.Add("BBBBBBBBBBB");
            aggregate.Add("CCCCCCCCCCC");
            aggregate.Add("DDDDDDDDDDD");

            //建造一个迭代器
            IIterator<string> iterator = aggregate.Create();
            while(iterator.HasNext())
            {
                Console.WriteLine("当前项："+iterator.Next());
            }
        }
    }

static void Main(string[] args)
        {
            new Client().Start();
            Console.ReadKey();
            Console.WriteLine("Hello, World!");
        }