首页 > 代码库 > 第15章 迭代器模式(Iterator Pattern)

第15章 迭代器模式(Iterator Pattern)

原文 第15章 迭代器模式(Iterator Pattern)

迭代器模式(Iterator Pattern)

 

   概述:

 

        在面向对象的软件设计中,我们经常会遇到一类集合对象,这类集合对象的内部结构可能有着各种各样的实现,但是归结起来,无非有两点是需要我们去关心的:一是集合内部的数据存储结构,二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则,所以我们要尽可能的去分解这些职责,用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为,抽象出一个迭代器类来负责,这样既可以做到不暴露集合的内部结构,又可让外部代码透明的访问集合内部的数据。

        提供一种方法顺序访问一个聚合对象中各个元素而又不需暴露该对象的内部表示。[GOF 《设计模式》]

 

   结构图:

 

    简单示例:可能中间对象引用的地方有点绕,但是写得很精髓

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 /// <summary>
    /// 抽象迭代器
    /// </summary>
    public interface Iterator
    {
        object GetCurrentItem();//当前项
        bool MoveNext();//是否遍历完
        void Next();//下一个
    }
    /// <summary>
    /// 具体迭代器
    /// </summary>
    public class ConcreteTerator : Iterator
    {
        public ConcreteList list;
        int index = 0;
        public ConcreteTerator(ConcreteList list)
        {
            this.list = list;
        }
        public bool MoveNext()
        {
            if (index < list.Length)
            {
                return true;
            }
            else
            {
                return false;
 
            }
        }
 
        public object GetCurrentItem()
        {
           return list.GetItem(index);
        }
        public void Next()
        {
            index++;
        }
    }
 
    /// <summary>
    /// 抽象聚集类
    /// </summary>
    public interface IList
    {
        //获取迭代器
        Iterator GetTerator();
 
    }
    /// <summary>
    /// 具体聚集类
    /// </summary>
    public class ConcreteList : IList
    {
        //这里就假设个Int数组对象
        public int[] list
        {
            get;
            set;
        }
        public int Length
        {
            get
            {
                return list.Length;
            }
        }
        public object GetItem(int i)
        {
          return  list[i];
        }
        public Iterator GetTerator()
        {
            //把本身传入到迭代器
            return new ConcreteTerator(this);
        }
    }
     
    //client
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteList list = new ConcreteList();
            list.list = new int[5] { 1, 2, 3, 4, 5 };
            Iterator terator = list.GetTerator();
            while (terator.MoveNext())
            {
                Console.WriteLine(terator.GetCurrentItem());
                terator.Next();
            }
            Console.ReadLine();
        }
    }

 

     效果:

 

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

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

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

 

     适用场景:

 

 

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

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

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

    

设计模式系列文章http://www.diyibk.com/post/39.html