行为型模式-迭代模式
using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
/// <summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
/// </summary>
public abstract class Aggregate
{
public abstract Iterator CreateIterator();
}
/// <summary>
/// 抽象迭代方法
/// </summary>
public abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
/// <summary>
/// 具体实现迭代类
/// </summary>
public class ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
public int Count
{
get { return this._items.Count; }
}
public object this[int index]
{
get { return this._items[index]; }
set { this._items[index] = value; }
}
/// <summary>
/// 创建迭对象
/// </summary>
/// <returns></returns>
public override Iterator CreateIterator()
{
return new ConcreteIterator(this);
}
}
/// <summary>
/// 具体迭代类
/// </summary>
public class ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
private int _current = 0;
/// <summary>
/// 将聚合类和具体迭代关联
/// </summary>
/// <param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
public override object First()
{
return aggregate[0];
}
public override object Next()
{
object ret = null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
public override bool IsDone()
{
return _current >= aggregate.Count;
}
public override object CurrentItem()
{
return aggregate[_current];
}
}
public class AppCient
{
public static void Main(string[] args)
{
ConcreteAggregate ca = new ConcreteAggregate();
ca[0] = "Item0";
ca[1] = "Item1";
ca[2] = "Item2";
ca[3] = "Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
/// <summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
/// </summary>
public abstract class Aggregate
{
public abstract Iterator CreateIterator();
}
/// <summary>
/// 抽象迭代方法
/// </summary>
public abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
/// <summary>
/// 具体实现迭代类
/// </summary>
public class ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
public int Count
{
get { return this._items.Count; }
}
public object this[int index]
{
get { return this._items[index]; }
set { this._items[index] = value; }
}
/// <summary>
/// 创建迭对象
/// </summary>
/// <returns></returns>
public override Iterator CreateIterator()
{
return new ConcreteIterator(this);
}
}
/// <summary>
/// 具体迭代类
/// </summary>
public class ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
private int _current = 0;
/// <summary>
/// 将聚合类和具体迭代关联
/// </summary>
/// <param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
public override object First()
{
return aggregate[0];
}
public override object Next()
{
object ret = null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
public override bool IsDone()
{
return _current >= aggregate.Count;
}
public override object CurrentItem()
{
return aggregate[_current];
}
}
public class AppCient
{
public static void Main(string[] args)
{
ConcreteAggregate ca = new ConcreteAggregate();
ca[0] = "Item0";
ca[1] = "Item1";
ca[2] = "Item2";
ca[3] = "Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{
/*
* 迭代模式意图:提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*
* 迭代模式实现要点:1、迭代抽象:访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行
* 3、迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构,有可能导致问题。
*
* 迭代模式优点:1、访问一个聚合对象的内容而无需暴露它的内部表示。
* 2、支持对聚合对象的多种遍历。
* 3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
*
* 迭代模式缺点:1、通过增加具体的接口,有可能增加代码的阅读难度
*
* 迭代模式适用场景:1、
*/
///<summary>
/// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
///</summary>
publicabstractclass Aggregate
{
publicabstract Iterator CreateIterator();
}
///<summary>
/// 抽象迭代方法
///</summary>
publicabstractclass Iterator
{
publicabstractobject First();
publicabstractobject Next();
publicabstractbool IsDone();
publicabstractobject CurrentItem();
}
///<summary>
/// 具体实现迭代类
///</summary>
publicclass ConcreteAggregate : Aggregate
{
private ArrayList _items=new ArrayList();
publicint Count
{
get { returnthis._items.Count; }
}
publicobjectthis[int index]
{
get { returnthis._items[index]; }
set { this._items[index] = value; }
}
///<summary>
/// 创建迭对象
///</summary>
///<returns></returns>
publicoverride Iterator CreateIterator()
{
returnnew ConcreteIterator(this);
}
}
///<summary>
/// 具体迭代类
///</summary>
publicclass ConcreteIterator : Iterator
{
private ConcreteAggregate aggregate;
privateint _current =0;
///<summary>
/// 将聚合类和具体迭代关联
///</summary>
///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}
//具体迭代方法
publicoverrideobject First()
{
return aggregate[0];
}
publicoverrideobject Next()
{
object ret =null;
if (_current<aggregate.Count-1)
{
ret = aggregate[_current++];
}
return ret;
}
publicoverridebool IsDone()
{
return _current >= aggregate.Count;
}
publicoverrideobject CurrentItem()
{
return aggregate[_current];
}
}
publicclass AppCient
{
publicstaticvoid Main(string[] args)
{
ConcreteAggregate ca =new ConcreteAggregate();
ca[0] ="Item0";
ca[1] ="Item1";
ca[2] ="Item2";
ca[3] ="Item3";
ConcreteIterator ci=new ConcreteIterator(ca);
object current = ci.First();
//开始迭代
while (current!=null)
{
Console.Write(current);
current = ci.Next();
}
}
}
}