结合项目实例 回顾传统设计模式（九）迭代器模式

关于迭代器模式，我们所需要知道的第一件事情就是它依赖于一个名为迭代器的接口。一旦我们有了这个接口，就可以为各种那个对象集合实现迭代器：数组、列表、散列表。

项目实例我们就拿用户角色模块来举例

背景

1.某用户作为应用管理员获取一组关于管理角色的arraylist权限组

2.该用户作为应用开发者获取一组关于开发角色的数组形式的权限组

...

 /// <summary>
    /// 迭代器接口
    /// </summary>
    public interface RoleIterator
    {
        //返回一个布尔值，让客户知道是否还有更多的元素
        bool hasnext();
        //返回下一个元素
        Object next();
    }

    /// <summary>
    /// 为管理者服务的迭代器
    /// </summary>
    public class ManagerRoleIterator : RoleIterator
    {
        ArrayList items;
        int position = 0;
        public ManagerRoleIterator(ArrayList RoleItems)
        {
            this.items = RoleItems;
        }
        public bool hasnext()
        {
            if (position >= items.Count || items[position] == null)
            {
                return false;
            }
            return true;
        }
        public Object next()
        {
            Object ri = items[position];
            position++;
            return ri;
        }
    }

    /// <summary>
    /// 管理者
    /// </summary>
    public class ManagerRole
    {
        ArrayList items;
        public RoleIterator createIterator()
        {
            return new ManagerRoleIterator(items);
        }
    }

    /// <summary>
    /// 为开发者服务的迭代器
    /// </summary>
    public class DevelopRoleIterator : RoleIterator
    {
        RoleItem[] items;
        int position = 0;
        public DevelopRoleIterator(RoleItem[] RoleItems)
        {
            this.items = RoleItems;
        }
        public bool hasnext()
        {
            if (position >= items.Length || items[position] == null)
            {
                return false;
            }
            return true;
        }
        public Object next()
        {
            RoleItem ri = items[position];
            position++;
            return ri;
        }
    }

    /// <summary>
    /// 开发者
    /// </summary>
    public class DevelopRole
    {
        static int MAX_ITEMS = 6;
        int numberofitems = 0;
        RoleItem[] items;
        public RoleIterator createIterator()
        {
            return new DevelopRoleIterator(items);
        }
    }

    /// <summary>
    /// 用户
    /// </summary>
    public class UserRole
    {
        ManagerRole mrole;
        DevelopRole drole;
        public UserRole(ManagerRole mrole, DevelopRole drole)
        {
            this.mrole = mrole;
            this.drole = drole;
        }
        public List<Object> getRole()
        {
            List<Object> lo = new List<object>();
            RoleIterator mi = mrole.createIterator();
            RoleIterator di = drole.createIterator();
            lo.AddRange(getRole(mi));
            lo.AddRange(getRole(di));
            return lo;
        }
        public List<Object> getRole(RoleIterator ri)
        {
            List<Object> li = new List<object>();
            while (ri.hasnext())
            {
                RoleItem ritem = (RoleItem)ri.next();
                li.Add(ritem);
            }
            return li;

        }

    }

总结：迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。把访问的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。