iterator - 访问者模式 VS 迭代器模式 : visiting across hierarchy class?

Question

我正在研究访问者模式的优势，并引用 Design Patterns :

But an iteratorcan't work across object structures with different types of elements. Forexample, the Iterator interface defined on page 295 can access only objects of type Item:

template <class Item> 
clas  Iterator { // ... Item CurrentItem() const; };

This implies that all elements the iterator can visit have a common parentclass Item. Visitor does not have this restriction...

class Visitor {
public:
// ...
void VisitMyType(MyType*);
void VisitYourType(YourType*);
};

MyType and YourType do not have to be related throughinheritance at all.

我同意这句话，但我想不出访问者模式可以探索其中收集的对象与父类(super class)无关的结构(如 List)的示例.

换句话说，你能给我举个例子，上面的特征是正确的吗？

Answer 1

首先，您应该知道这些模式的用途。

迭代器模式用于顺序访问聚合而不暴露其底层表示。所以你可以在迭代器后面隐藏一个列表或数组或类似的聚合。

访问者模式用于在不改变元素本身的实现的情况下对元素结构执行操作。

所以你在两种不同的情况下使用这些模式，而不是相互替代。

在访问者模式中，您在要访问的每个元素中实现一个接口(interface) IAcceptor。所以访问者模式不依赖于父类(super class)，而是依赖于接口(interface)

public interface IAcceptor
{
    public void Accept(IVisitor visitor);
}

因此，如果您有一个对象列表，则可以对其进行迭代并访问实现 IAcceptor 的对象

public VisitorExample()
{
    MyVisitorImplementation visitor = new MyVisitorImplementation();
    List<object> objects = GetList();
    foreach(IAcceptor item in objects)
        item.Accept(visitor);
}


public interface IVisitor
{
    public void Visit(MyAcceptorImplementation item);
    public void Visit(AnotherAcceptorImplementation item);
}

public class MyAcceptorImplementation : IAcceptor
{ 
    //Some Code ...
    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }
}

为了完成这里的代码，如果访问者访问我的或其他接受器的实现，则访问者将其写入控制台。

public class MyVisitorImplementation : IVisitor
{
        public void Visit(MyAcceptorImplementation item)
        {
            Console.WriteLine("Mine");
        }
        public void Visit(AnotherAcceptorImplementation item)
        {
            Console.WriteLine("Another");
        }
}

有关更多有用的示例和更好的解释，请查看 Visitor Pattern和 Iterator Pattern

编辑:这是一个同时使用访问者和迭代器的示例。迭代器只是如何在聚合中移动的逻辑。使用层次结构会更有意义。

public VisitorExample2()
{
    MyVisitorImplementation visitor = new MyVisitorImplementation();
    List<object> myListToHide = GetList();

    //Here you hide that the aggregate is a List<object>
    ConcreteIterator i = new ConcreteIterator(myListToHide);

    IAcceptor item = i.First();
    while(item != null)
    {
       item.Accept(visitor);
       item = i.Next();
    }
    //... do something with the result
}