设计模式--迭代器模式

using System;
using System.Collections.Generic;

// 抽象迭代器
interface IIterator<T> 
{
    T First();
    T Next();
    bool IsDone();
    T CurrentItem();
}

// 具体迭代器
class ConcreteIterator<T> : IIterator<T>
{
    private ConcreteAggregate<T> _aggregate;
    private int _current = 0;

    public ConcreteIterator(ConcreteAggregate<T> aggregate) 
    {
        _aggregate = aggregate;
    }

    public T First() 
    {
        return _aggregate[0];
    }

    public T Next() 
    {
        T ret = default(T);
        if (_current < _aggregate.Count - 1) 
        {
            ret = _aggregate[++_current];
        }
        return ret;
    }

    public bool IsDone() 
    {
        return _current >= _aggregate.Count;
    }

    public T CurrentItem() 
    {
        return _aggregate[_current];
    }
}

// 抽象聚合类
interface IAggregate<T> 
{
    IIterator<T> CreateIterator();
}

// 具体聚合类
class ConcreteAggregate<T> : IAggregate<T>
{
    List<T> items = new List<T>();

    public IIterator<T> CreateIterator() 
    {
        return new ConcreteIterator<T>(this);
    }

    public int Count 
    {
        get 
        {
            return items.Count;
        }
    }

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

    public T this[int index] 
    {
        get 
        {
            return items[index];
        }
    }
}

class Program 
{
    static void Main() 
    {
        // 创建聚合对象
        var aggregate = new ConcreteAggregate<int>();

        // 添加元素
        aggregate.Add(1);
        aggregate.Add(2);
        aggregate.Add(3);
        aggregate.Add(4);
        aggregate.Add(5);

        // 获取迭代器
        var iterator = aggregate.CreateIterator();

        // 遍历容器中的元素
        Console.WriteLine("Iterating over collection:");
        for (var item = iterator.First(); !iterator.IsDone(); item = iterator.Next()) 
        {
            Console.WriteLine(item);
        }
    }
}