在 C# 中使用带有泛型的访问者模式

Question

我想知道下面的访问者模式是否可以接受。 从 Accept() 或 Visit() 调用返回时我感觉有点不舒服 - 这是此模式的适当用法吗？如果不合适，为什么不呢？

注意：对长代码示例表示歉意，似乎有必要了解我正在做的事情，因为访问者似乎总是有点参与......

interface IAnimalElement<T>
{
   T Accept(IAnimalVisitor<T> visitor);
}

interface IAnimalVisitor<T>
{
    T Visit(Lion lion);
    T Visit(Peacock peacock);
    T VisitZoo(List<Animal> animals);
}

abstract class Animal
{
    public int Age { get; protected set; }
}

class Lion : Animal, IAnimalElement<int>
{
    public Lion(int age)
    {
        Age = age;
    }

    public int Accept(IAnimalVisitor<int> visitor)
    {
        return visitor.Visit(this);
    }
}

class Peacock : Animal, IAnimalElement<int>
{
    public Peacock(int age)
    {
        Age = age;
    }

    public int Accept(IAnimalVisitor<int> visitor)
    {
        return visitor.Visit(this);
    }
}

class AnimalAgeVisitor : IAnimalVisitor<int>
{
    public int TotalAge { get; private set; }

    int IAnimalVisitor<int>.Visit(Lion lion)
    {
        TotalAge += lion.Age;
        return lion.Age;
    }

    int IAnimalVisitor<int>.Visit(Peacock peacock)
    {
        TotalAge += peacock.Age + 10;
        return peacock.Age + 10; // peacocks ages are always -10y, correct.
    }

    public int VisitZoo(List<Animal> animals)
    {
        // Calculate average animal age.

        int sum = 0;
        int count = 0;
        foreach (IAnimalElement<int> animal in animals)
        {
            sum += animal.Accept(this);
            ++count;
        }

        return count == 0 ? 0 : sum / count;
    }
}

class Program
{
    static void Main(string[] args)
    {
        List<Animal> animals = new List<Animal>() { new Lion(10), 
          new Lion(15), new Peacock(3), new Lion(2), new Peacock(9) };

        AnimalAgeVisitor visitor = new AnimalAgeVisitor();

        Console.WriteLine("Average age = {0}, Total age = {1}", 
            visitor.VisitZoo(animals), visitor.TotalAge);
    }
}

Answer 1

对我来说，这感觉实施有点犹豫。

让您的 Visit 和 Accept 方法返回 void 并跟踪 Visitor 对象中的所有状态。 最后询问一下。

或者...

让访问和接受返回正在进行的状态并以功能方式接受传入的正在进行的状态。

如果您选择第二个选项，我不太确定是否需要访问者对象或模式，您可以使用迭代器、函数和一些瞬态状态。

Answer 2

简短回答：我没有发现公开 IVisitor 返回通用参数有任何问题。
请参阅 FxCop 规则。

然后它允许使用不同的IVisitor，每个都返回不同的值。

但是，就您的情况而言，Visitor 没有用，因为每种动物都有 Age 属性，因此所有操作都可以使用 Animal 或新的 <强>IAnimal界面。

另一种方法是使用多重调度，但代价是丢失强类型。

当您想要替换（或避免编写) 像这样的开关：

IAnimal animal = ...;
switch (animal.GetType().Name)
{
  case "Peacock":
    var peacock = animal as Peacock;
    // Do something using the specific methods/properties of Peacock
    break;
  case "Lion":
    var peacock = animal as Lion;
    // Do something using the specific methods/properties of Lion
    break;
   etc...
}

或者嵌套的if-then-else等价物。

其目的是通过使用多态性将实例路由到与其类型相关的例程，然后避免丑陋的 if-then-else/switch 语句和手动转换。 此外，它还有助于减少不相关代码之间的耦合。

替代方法是在类树中添加一个虚拟方法来访问。 然而，有时这是不可能或不可取的：

• 可访问类代码不可修改（例如不拥有）
• 可访问类代码与访问代码无关（将其添加到类中意味着降低班级的凝聚力）。

这就是为什么它经常被用来遍历对象树（html 节点、词法分析器标记等）。 Visitor 模式意味着以下接口：

• IVisitor

  /// <摘要> 
    /// 为访问其他类的类实现的接口。  
    /// 有关更多详细信息，请参阅访问者设计模式。 
    ///  
    /// 访问的类型。 
    /// 结果的类型。 
    公共接口 IVisitor   : IVisitor 电视访问过的地方 : IVisitable 
    { 
        TResult 访问(TVisited 已访问); 
    } 
  
    /// <摘要> 
    /// 标记接口。 
    ///  
    公共接口 IVisitor{} 
    

• IVisitable

  /// <摘要> 
    /// 为访问者可访问的类实现的接口。 
    /// 有关更多详细信息，请参阅访问者设计模式。 
    ///  
    /// 访问者的类型。 
    /// 结果的类型。 
    公共接口 IVisitable   : IVisitable 所在 TVisitor : IVisitor 
    { 
        TResult Accept(TVisitor 访客); 
    } 
  
    /// <摘要> 
    /// 标记接口。 
    ///  
    公共接口 IVisitable {} 
    

每个IVisitable 中Accept 的实现应该调用Visit(this)。

Answer 3

可访问的接受方法不应返回任何内容。 接受仅应指示访问者在访问之后或访问期间要访问什么。

Answer 4

这很常见。 我不知道你是否可以在 C# 中做到这一点，但在 Java 中，通常将 Accept 方法保留为通用，因此返回的内容由访问者而不是访问者决定：

interface IAnimalElement
{
   <T> T Accept(IAnimalVisitor<T> visitor);
}


interface IAnimalVisitor<T> 
{
   T Visit(Peacock animal);
  ...
}

对于过程，一个 IAnimalVisitorIAnimalVisitornull 的 code> 。