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!");
        }