7in10笔记：泡妞之迭代子模式

类关系图


类角色说明
Aggregate:一个数组或队列的抽象对象
CreateAggregate:真实的数组货队列的对象，是模式当中真实被访问和操作的。通过自身方法返回迭代器，用不同的迭代对象封装对自己不同的访问方法。
Iterator:封装迭代器的基本操作
Concretelterator:真实的迭代器

意图
Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。

适用性

1．访问一个聚合对象的内容而无需暴露它的内部表示。

2．支持对聚合对象的多种遍历。

3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

泡妞的例子
我爱上了Mary，不顾一切的向她求婚。?

Mary：“想要我跟你结婚，得答应我的条件”?

我：“什么条件我都答应，你说吧”?

Mary：“我看上了那个一克拉的钻石”?

我：“我买，我买，还有吗？”?

Mary：“我看上了湖边的那栋别墅”?

我：“我买，我买，还有吗？”?

Mary：“你的小弟弟必须要有50cm长”?

我脑袋嗡的一声，坐在椅子上，一咬牙：“我剪，我剪，还有吗？”?

……?

泡妞的代码

using System;
using System.Collections;
public abstract class Iterator
{
    public abstract object First();
    public abstract object Next();
    public abstract object Current();
    public abstract bool IsLast();
}
public class ConcreteIterator:Iterator
{
    private MarriageRequire require;
    private int current=0;
    public ConcreteIterator(MarriageRequire require)
    {
        this.require=require;
    }
    public override object First()
    {
        current=0;
        return require[0];
    }
    public override object Next()
    {
        object result=null;
        if(current<require.Count-1)
        {
            result=require[++current];
        }
        return result;
    }
    public override object Current()
    {
        return require[current];
    }
    public override bool IsLast() 
    { 
      return current >= require.Count ? true : false ; 
    } 
}
interface Require
{
    Iterator CreateIterator();
}
public class MarriageRequire:Require
{
    private ArrayList list=new ArrayList();
    public Iterator CreateIterator()
    {
        return new ConcreteIterator(this);
    }
    public int Count 
    { 
      get{ return list.Count; } 
    } 
  
    public object this[int index] 
    { 
      get{ return list[index]; } 
      set{ list.Insert(index, value); } 
    }  
}
public class MyClass
{
    public static void Main()
    {
        MarriageRequire require=new MarriageRequire();
        require[0]="我看上了那个一克拉的钻石";
        require[1]="我看上了湖边的那栋别墅";
        require[2]="你的小弟弟必须要有50cm长";
        
        ConcreteIterator i=require.CreateIterator() as ConcreteIterator;
        
        object item = i.First(); 
        while (item != null) 
        { 
            Console.WriteLine(item); 
            item = i.Next(); 
        }  
        RL();
    }
    
    Helper methods#region Helper methods

    private static void WL(object text, params object[] args)
    {
        Console.WriteLine(text.ToString(), args);    
    }
    
    private static void RL()
    {
        Console.ReadLine();    
    }
    
    private static void Break() 
    {
        System.Diagnostics.Debugger.Break();
    }

    #endregion
}

迭代子模式
迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的 界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

备注

1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。