c#设计模式——迭代器模式

一 概要

1.1 行为型模式

1. 特别关注对象之间的通信。描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。

1.2 定义

1. 提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式。

二 UML类图

三 例子

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate aggregate = new ConcreteAggregate();
            aggregate[0] = 1;
            aggregate[1] = 2;
            aggregate[2] = 3;
            aggregate[3] = 4;

            Iterator iterator = aggregate.CreateIterator();
            while (!iterator.IsDone())
            {
                iterator.Next();
            }
        }
    }

    public interface Iterator
    {
        object First();
        object Next();
        bool IsDone();
        object CurrentItem();
    }

    public interface IAggregate
    {
        Iterator CreateIterator();
    }

    public class ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate;
        private int current;

        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
            current = 0;
        }

        public object CurrentItem()
        {
            return aggregate[current];
        }

        public object First()
        {
            return aggregate[0];
        }

        public bool IsDone()
        {
            return current >= aggregate.Count;
        }

        public object Next()
        {
            object obj = null;
            current++;
            if (current < aggregate.Count)
            {
                obj = aggregate[current];
            }
            return obj;
        }
    }

    public class ConcreteAggregate : IAggregate
    {
        private List<object> items;

        public ConcreteAggregate()
        {
            items = new List<object>();
        }

        public object this[int index]
        {
            get {
                return items[index];
            }
            set
            {
                items.Insert(index, value);
            }
        }

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

        public Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
    }

四 优缺点

4.1 优点

1. 迭代器模式使得访问一个聚合对象的内容而无需暴露它的内部表示。
2. 迭代器模式为遍历不同的集合结构提供了一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

4.2 缺点

1. 增加了类的个数，这在一定程度上增加了系统的复杂性。

五 .Net中的迭代器实现

5.1 IEumerator

IEumerator 对应了 迭代接口Iterator。

    public interface IEnumerator
    {
        object Current { get; }
        bool MoveNext();
        void Reset();
    }

5.2 IEumerable

IEumerable 对应了聚集接口IAggregate。

    public interface IEnumerable
    {
        IEnumerator GetEnumerator();
    }

六 使用场景

1. 当需要为聚合对象提供多种遍历方式时。
2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。