迭代器模式 Iterator

   迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而有不暴露起内部的表示。 【Head First design pattern】

下面来分析一个Demo:
这个就是"聚合对象中的元素"。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->  class ItemFir:IItem
    {
        string name;
        ItemFlag flag;

        public ItemFlag Flag
        {
            get { return flag; }
            set { flag = value; }
        }
        
        public ItemFir(string name, string des,ItemFlag itemflag)
        {
            this.des = des;
            this.name = name;
            this.flag = itemflag;
        }
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        string des;

        public string Des
        {
            get { return des; }
            set { des = value; }
        }
    }

ClassA 中使用数组来存储“元素”。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->  class ClassA
    {
        IItem[] myitemlist = new ItemFir[10];
        #region
        public ClassA()
        {
            ItemFlag flag = ItemFlag.LOW;
            for (int i = 0; i < myitemlist.Length; i++)
            {
                flag = (ItemFlag)System.Enum.Parse(typeof(ItemFlag), "" + (i - (myitemlist.Length / 2)) % 2 + "");
                // 获得 -1,0,1对应的枚举
                myitemlist[i] = new ItemFir(String.Format("ClassA{0}",i),String.Format("ClassA{0}Des",i),flag);
            }
        }
        public string GetDes()
        {
            return "I'am ClassA";
        }
        public void Add(IItem item)
        {
        }
        public void Remove(IItem item)
        {
        }
        public IItem Get(int i)
        {
            return myitemlist[i];
        }
        #endregion
        public IItem[] GetAll()
        {
            return myitemlist;
        }
        //public IIterator CreateIterator()
        //{
        //    return new ClassAIterator(myitemlist);
        //}
    }

ClassB 中使用List来存储“元素”。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->  class ClassB
    {
        List<IItem> myitemlist = new List<IItem>();
        #region
        public ClassB()
        {
            myitemlist.Add(new ItemFir("ClassB Item1", "ClassB Item1 Des", ItemFlag.HIGH));
            myitemlist.Add(new ItemFir("ClassB Item2", "ClassB Item3 Des", ItemFlag.LOW));
            myitemlist.Add(new ItemFir("ClassB Item3", "ClassB Item3 Des", ItemFlag.HIGH));
            myitemlist.Add(new ItemFir("ClassB Item4", "ClassB Item4 Des", ItemFlag.MEDIAL));
            myitemlist.Add(new ItemFir("ClassB Item5", "ClassB Item5 Des", ItemFlag.LOW));
        }
        public string GetDes()
        {
            return "I'am ClassB";
        }

        public void AddItem(IItem item)
        {
        }
        public void RemoveItem(IItem item)
        {
        }
        public IItem GetItem(int i)
        {
            return myitemlist[i];
        }
        #endregion
        public List<IItem> GetAllItem()
        {
            return myitemlist;
        }
        //public IIterator CreateIterator()
        //{
        //    return new ClassBIterator(myitemlist);
        //}
    }

ItemFlag 源码：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->enum ItemFlag
    {
        LOW = -1,
        MEDIAL = 0,
        HIGH = 1,
    }

测试代码：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->  static void Main(string[] args)
        {
            ClassA classA = new ClassA();
            IItem[] itemlistA = classA.GetAll();
            Console.Write("ClassA\n");


            for (int i = 0; i < itemlistA.Length; i++)
            {
                if (itemlistA[i].Flag == ItemFlag.LOW)
                    Console.Write(itemlistA[i].Name + "  " + itemlistA[i].Flag + "\n");
            }
            Console.Write("ClassB\n");
            ClassB classB = new ClassB();
            List<IItem> itemlistB = classB.GetAllItem();

            for (int j = 0; j < itemlistB.Count; j++)
            {
                if (itemlistB[j].Flag == ItemFlag.LOW)
                    Console.Write(itemlistB[j].Name + " " + itemlistB[j].Flag + "\n");
            }
}

我们希望把 ClassA 中和ClassB 中所有ItemFalg 值为LOW的元素选择出来。其实对于客户来说没必要知道你用数组还是list来保存的。客户需要用不同的方式来访问聚合，也显得不够优雅。（ itemlistB.Count ，itemlistA.Length）还有像上面如果有10个类就得用十个循环。
现在我们看看用迭代器模式怎么做：

1.定义接口：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> interface IIterator
    {
        bool HasNext();
        IItem Next();
        
    }

2. 实现迭代器：
classA对应的迭代器。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->  class ClassAIterator : IIterator
    {
        int posion;
        IItem[] item;
        public ClassAIterator(IItem[] item)
        {
            this.item = item;
        }

        public bool HasNext()
        {
            return posion <= item.Length - 1;
        }

        public IItem Next()
        {
            return item[posion++];
        }

    }

ClassB的迭代器：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->

Code
<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->    class ClassBIterator:IIterator
    {

        int posion;
        List< IItem> item;
       public ClassBIterator( List< IItem> item)
a

分享到：

【转】C# 特性（Attribute）入门 | 策略模式 strategy

• 2008-06-25 16:01
• 浏览 654
• 评论(0)
• 查看更多

相关推荐

【Java设计模式】(1)迭代器模式Iterator

迭代器模式（Iterator Pattern）是Java设计模式中的行为模式之一，它提供了一种方法来顺序访问聚合对象的元素，而又不暴露其底层表示。在Java中，迭代器模式被广泛应用于集合类，如ArrayList、LinkedList等，通过...

设计模式(C#)之迭代器模式(Iterator Pattern)

迭代器模式是软件设计模式中的一种行为模式，它在C#等面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户遍历一个聚合对象（如数组、集合或列表）的所有元素，而无需了解底层的实现细节。下面将详细...

设计模式之迭代器模式（Iterator）

例如，在Java中，`Iterable`接口和`Iterator`接口就是实现迭代器模式的关键。`Iterable`接口定义了获取迭代器的方法`iterator()`，而`Iterator`接口提供了`hasNext()`和`next()`方法，分别用于检查是否还有下一个...

迭代器模式（Iterator Pattern）原理图

迭代器模式（Iterator Pattern）是设计模式中的一种行为模式，它允许顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式提供了一种方法，可以顺序地访问一个聚合对象中的各个元素，而又...

(行为型模式) Iterator 迭代器模式

C#面向对象设计模式 (行为型模式) Iterator 迭代器模式 视频讲座下载

23钟设计模式之迭代器模式模式

在迭代器模式中，存在三个主要角色：迭代器（Iterator）、聚合对象（Aggregate）和客户端（Client）。迭代器负责遍历聚合对象中的元素，聚合对象提供了元素的集合，而客户端则使用迭代器来遍历聚合对象中的元素。 ...

设计模式C++学习之迭代器模式（Iterator）

迭代器模式是软件设计模式中的行为模式之一，它在C++编程中有着广泛的应用。这个模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。通过迭代器，用户可以遍历集合中的所有元素，而无需知道如何...

迭代器Iterator.txt

迭代器模式是一种常用的设计模式，它允许我们以一种顺序访问集合对象的方式遍历其元素，而无需暴露该对象的内部表示。接下来，我们将详细讨论这一模式的关键概念、结构及其在Java集合框架中的具体实现。 ### 一、...

迭代器模式（Iterator）C++实现

迭代器模式是一种设计模式，它提供了一种方法来顺序访问聚合对象的元素，而又不暴露其底层表示。在C++中，迭代器模式通常通过定义一个接口，该接口允许访问和遍历聚合对象的元素，而无需暴露其内部结构。这种模式在...

迭代器模式代码示例

迭代器模式是一种设计模式，属于行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，迭代器模式被广泛应用于容器类，如ArrayList、LinkedList等，使得我们可以...

设计模式的迭代器模式的例子

迭代器模式是软件设计模式中的一种行为模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，迭代器模式被广泛应用于容器类，如ArrayList、LinkedList等，使得我们可以方便...

设计模式之迭代器模式

迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java中，迭代器模式是通过接口实现的，这使得我们可以遍历任何实现了`Iterable`接口的对象，例如集合框架中的`...

java迭代器模式实现正反向遍历

在Java编程语言中，迭代器模式（Iterator Pattern）是一种常用的设计模式，用于顺序访问集合对象中的元素，而无需暴露其底层表示。这种模式提供了一种方法来访问一个聚合对象的元素，而无需暴露该对象的内部结构。在...

迭代器模式Demo

迭代器模式是一种设计模式，它在软件工程中扮演着重要的角色，特别是在处理集合或容器类对象的遍历操作时。这种模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。在Java、C#等面向对象语言中，...

设计模式-迭代器模式（讲解及其实现代码）

在Java、C#等面向对象语言中，迭代器模式的应用非常广泛，例如Java中的`Iterable`接口和`Iterator`接口，C#中的`IEnumerable`接口和`IEnumerator`接口。这些接口为实现迭代器模式提供了标准的方式。 迭代器模式的...

PHP设计模式之迭代器模式Iterator实例分析【对象行为型】

迭代器模式是面向对象设计中的一种行为模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层结构。在PHP中，迭代器模式通过提供一个接口，使得客户端可以遍历任何类型的集合，如数组、关联数组或自定义的数据...

Android迭代器模式demo

迭代器模式是设计模式中的一种行为模式，它提供了一种顺序访问聚合对象的元素而无需暴露其底层表示的方法。在Android开发中，迭代器模式的应用可以帮助我们更好地管理和遍历集合数据，尤其在处理复杂的逻辑或者需要...

IteratorPattern 迭代设计模式

迭代器模式（IteratorPattern）是设计模式中的一种行为模式，它提供了一种顺序访问聚合对象元素的方法，同时又不暴露其底层表示。这种模式允许我们遍历集合对象的元素，而无需暴露其内部结构。在Java、C#等面向对象...