谈恋爱是两个人的事，结婚是两个家庭的事。最近事也挺多的。我也挺烦的，有时候，我也为自己的将来担忧，我自认为自己的技术过硬，但是千里马只有遇到伯乐才能发挥作用。

技术上让我高兴的事是，有个技术问题终于突破了，花了我1个多月时间惦记这事，终于我又花一天时间，不停的尝试，坚持，最后终于搞定了。主要是用IL语言操作实体取值赋值方法，完全个人独立所完成。使用这种方法，我的开源底层框架效率会提升数倍。也是我开源框架的亮点。目前我的开源应用程序底层框架在码云托管平台上托管着，github上只留有最原始的操作数据库版本。至于这个项目什么时候公开，待以后再决定。目前还属于建设完善阶段。

重要是事多说几遍，对象是具有空间的，空间是可以放东西的，如果这个东西是另一个对象，那么放的是这个对象的引用。这样，两个对象就发生关系了，即可以访问的关系。

迭代器模式就是操作集合的一个对象，既然能操作集合，肯定存了集合的引用。集合的基类接口已经约束了，迭代集合对象。

迭代器即一个对象操作另一个对象。

直接上例子，我来解释

//抽象的描述了关系，将来的Aggregate存了Iterator 对象的引用，可以访问到Iterator 对象。

abstract class Aggregate
{
public abstract Iterator CreateIterator();
}

//具体对象

class ConcreteAggregate : Aggregate
{

//对象空间中的集合
private IList<object> items = new List<object>();
public override Iterator CreateIterator()
{

//同样，生成的对象也存了宿主对象，即在ConcreteIterator这个对象中也可以访问到宿主对象
return new ConcreteIterator(this);
}

public int Count
{
get { return items.Count; }
}

//索引的方式操作对象中的集合

public object this[int index]
{
get { return items[index]; }
set { items.Insert(index, value); }
}
}

//迭代器抽象对象的约束

abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}

//具体的迭代器对象

class ConcreteIterator : Iterator
{

private ConcreteAggregate aggregate;
private int current = 0;

//存了宿主对象的引用，可以访问到宿主对象

public ConcreteIterator(ConcreteAggregate aggregate)
{
this.aggregate = aggregate;
}

//都是访问宿主对象

public override object First()
{
return aggregate[0];
}

public override object Next()
{
object ret = null;
current++;

if (current < aggregate.Count)
{
ret = aggregate[current];
}

return ret;
}

public override object CurrentItem()
{
return aggregate[current];
}

public override bool IsDone()
{
return current >= aggregate.Count ? true : false;
}

}

//集合对象，还可以这样写

//Aggregate a = new ConcreteAggregate();

ConcreteAggregate a = new ConcreteAggregate();

a[0] = "大鸟";
a[1] = "小菜";
a[2] = "行李";
a[3] = "老外";
a[4] = "公交内部员工";
a[5] = "小偷";

//这个地方也可以这样写

//Iterator i = a.CreateIterator();

Iterator i = new ConcreteIterator(a);

object item = i.First();
while (!i.IsDone())
{
Console.WriteLine("{0} 请买车票!", i.CurrentItem());
i.Next();
}

总结：不要看设计模式，要看思想，这个迭代器模式的思想就是宿主可以访问其中对象，其中对象也可以访问宿主。

最近比较忙，这篇写了好几天，程序员最重要的就是工作态度，工作习惯，工作经验，编程思想。

玩面向对象都是在玩引用的，因为通过引用可以让所关联的对象互相访问。

不说了，大家努力吧，我后天订婚。