C# 中的用户可扩展访问者模式

Question

是否可以在 C# 中创建用户可扩展的访问者模式？ （最好是.net 3.5）

我在库中有一组类，我希望使用访问者模式向其中添加功能。问题是库的用户也可以创建自己的类。这意味着您需要创建一个特殊的访问者来接受新的类类型，但我们的 Accept 方法设置为接收基本类型。如何让派生类在派生访问者中调用正确的方法。

或者还有另一种方法可以做到“如果是这种类型，就这样做”？

一些示例代码：

/* In library */
namespace VisitorPattern.System
{
   interface IThing
   {
      void Accept(SystemVisitor visitor);
      void ThingMethodA(...);
      void ThingMethodB(...);
   }

   class SystemThingA : IThing
   {
      public void Accept(SystemVisitor visitor) { visitor.Visit(this); }
      ...ThingMethods...
   }
   class SystemThingB : IThing
   {
      public void Accept(SystemVisitor visitor) { visitor.Visit(this); }
      ...ThingMethods...
   }
   class SystemThingC : IThing
   {
      public void Accept(SystemVisitor visitor) { visitor.Visit(this); }
      ...ThingMethods...
   }

   class SystemVisitor
   {
      public SystemVisitor(object specialSystemServices) { }
      public virtual void Visit(SystemThingA thing) { Console.WriteLine("SystemThingA"); }
      public virtual void Visit(SystemThingB thing) { Console.WriteLine("SystemThingB"); }
      public virtual void Visit(SystemThingC thing) { Console.WriteLine("SystemThingC"); }
      public virtual void Visit(IThing thing) { Console.WriteLine("sysvis:IThing"); }
   }
}

/* in user code */
namespace VisitorPattern.User
{
   using VisitorPattern.System;

   class UserThingA : IThing
   {
      public void Accept(SystemVisitor visitor)
      {
         var userVisitor = visitor as UserVisitor; 
         if (userVisitor == null) throw new ArgumentException("visitor"); 
         userVisitor.Visit(this);
      }
      ...ThingMethods...
   }
   class UserThingB : IThing
   {
      public void Accept(SystemVisitor visitor)
      {
         var userVisitor = visitor as UserVisitor;
         if (userVisitor == null) throw new ArgumentException("visitor");
         userVisitor.Visit(this);
      }
      ...ThingMethods...
   }
   class UserThingC : IThing
   {
      public void Accept(SystemVisitor visitor)
      {
         var userVisitor = visitor as UserVisitor;
         if (userVisitor == null) throw new ArgumentException("visitor");
         userVisitor.Visit(this);
      }
      ...ThingMethods...
   }

   // ?????
   class UserVisitor : SystemVisitor
   {
      public UserVisitor(object specialSystemServices, object specialUserServices) : base(specialSystemServices) { }

      public void Visit(UserThingA thing) { Console.WriteLine("UserThingA"); }
      public void Visit(UserThingB thing) { Console.WriteLine("UserThingB"); }
      public void Visit(UserThingC thing) { Console.WriteLine("UserThingC"); }
      public override void Visit(IThing thing) { Console.WriteLine("uservis:IThing"); }
   }

   class Program
   {
      static void Main(string[] args)
      {
         var visitor = new UserVisitor("systemservice", "userservice");
         List<IThing> mylist = new List<IThing> { new UserThingA(), new SystemThingB(), new SystemThingC(), new UserThingC() };
         foreach (var thing in mylist)
         {
            thing.Accept(visitor);
         }
      }
   }
}

Answer 1

看来你把一切都搞反了。首先我们先来说一下里氏替换原理。它说任何类型都应该可以被基本类型替换。这也适用于访客模式。

如果您有一个名为 void Accept(IVisitor Visitor) 的方法，那么访问的是 FancyVisitor 还是 SipleVisitor 都没有关系。

访问者模式的整体思想是，主体（即被访问的类）不应该比访问者所实现的契约（基类或接口）了解更多关于访问者的信息。每个 Visitor 类应该特定于被访问的某个类。

这就是你的代码的问题。您正在尝试创建一个可以访问所有系统组件的通用访问者类。这完全是错误的。

在我看来，您有两个选择：

您想要从所有系统组件收集相同类型的信息。

很简单。创建所有系统组件都实现的新接口。然后将访问者更改为Visit(ISystemCompoent subject)。

您想要从每个系统组件收集不同类型的信息

然后您需要创建不同访问者基类（或接口）。

Answer 2

不，不可能将访问者模式与可扩展类层次结构的愿景混合在一起。它们是相互排斥的。

Answer 3

此一系列博客文章中的一个解决方案可能涉及使用“接口和动态类型转换以克服访问者模式的可扩展类层次结构问题”

例如：（

   class UserThingC : IThing
   {
      public void Accept(SystemVisitor visitor)
      {
         var userVisitor = visitor as UserVisitor;
         if (userVisitor == null) throw new ArgumentException("visitor");
         userVisitor.Visit(this);
      }
   }

并不是说这是最好的，只是一种替代方案）

Answer 4

是的，您可以使用反射来做到这一点。使用访问者模式的主要思想是双重调度。使用反射，您可以从任何访问者获取所有 Visit(...) 方法，并根据 Visit 方法的参数类型调用正确的方法。

如果您选择这条路线，则不一定需要访问者或您正在访问的元素的继承层次结构。事实上，元素类甚至不需要了解访问者接口（或基类）。

为了清楚起见，下面是一个代码示例，它实现了使用反射进行双重调度的通用访问者。使用 GenericVisitor::AcceptVisitor(...)，您可以获取任何元素（无论是否派生）来调用任何访问者（无论是否派生）中的正确方法，只要Visitor T 为该特定元素类定义了一个方法 Visit(...)。

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace VisitorPattern
{
    class GenericVisitor<T>
    {
        // Dictionary whose key is the parameter type and value is the MethodInfo for method "Visit(ParameterType)"
        static Dictionary<Type, MethodInfo> s_visitorMethodDict;
        static GenericVisitor()
        {
            s_visitorMethodDict = new Dictionary<Type, MethodInfo>();

            Type visitorType = typeof(T);
            MethodInfo[] visitorMethods = visitorType.GetMethods();

            // Loop through all the methods in class T with the name "Visit".
            foreach (MethodInfo mi in visitorMethods)
            {
                if (mi.Name != "Visit")
                    continue;

                // Ignore methods with parameters > 1.
                ParameterInfo[] parameters = mi.GetParameters();
                if (parameters.Length != 1)
                    continue;

                // Store the method in the dictionary with the parameter type as the key.
                ParameterInfo pi = parameters[0];
                if (!s_visitorMethodDict.ContainsKey(pi.ParameterType))
                    s_visitorMethodDict.Add(pi.ParameterType, mi);
            }
        }

        public static bool AcceptVisitor(object element, T visitor)
        {
            if (element == null || visitor == null)
                return false;

            Type elementType = element.GetType();

            if (!s_visitorMethodDict.ContainsKey(elementType))
                return false;

            // Get the "Visit" method on the visitor that takes parameter of the elementType
            MethodInfo mi = s_visitorMethodDict[elementType];

            // Dispatch!
            mi.Invoke(visitor, new object[] { element });

            return true;
        }
    }

    // Element classes (note: they don't necessarily have to be derived from a base class.)
    class A { }
    class B { }

    class Visitor
    {
        public void Visit(A a) { System.Console.WriteLine("Visitor: Visited A"); }
        public void Visit(B b) { System.Console.WriteLine("Visitor: Visited B"); }
    }

    interface IVisitor
    {
        void Visit(A a);
        void Visit(B b);
    }

    class DerivedVisitor : IVisitor
    {
        public void Visit(A a) { System.Console.WriteLine("DerivedVisitor: Visited A"); }
        public void Visit(B b) { System.Console.WriteLine("DerivedVisitor: Visited B"); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Object a = new A();
            Object b = new B();

            // Example of Visitor that doesn't use inheritance.
            Visitor v1 = new Visitor();
            GenericVisitor<Visitor>.AcceptVisitor(a, v1);
            GenericVisitor<Visitor>.AcceptVisitor(b, v1);

            // Example of Visitor that uses inheritance.
            IVisitor v2 = new DerivedVisitor();
            GenericVisitor<IVisitor>.AcceptVisitor(a, v2);
            GenericVisitor<IVisitor>.AcceptVisitor(b, v2);
        }
    }
}

Answer 5

您可以像这样使用新的dynamic关键字：

public class Visitable1
{
    public void Accept(dynamic visitor)
    {
        visitor.Visit(this);
    }
}

public class DynamicVisitor
{
    public void Visit(Visitable1 token)
    {
        // Call token methods/properties
    }
}

但是，您将代码暴露给MissingMethodException

Answer 6

是的，你可以这样做。

1. 更改所有 UserThing 的 Accept(SystemVisitor guest) 方法以接受 UserVisitor。

2. 为所有 UserThing 添加一个抽象基类

3. 在抽象基类中添加Accept 方法尝试将访问者从 SystemVisitor 转换为 UserVisitor。如果成功，它将调用 UserThing 上的 Accept 方法。

   public override void Accept(SystemVisitor 访客)
   {
       var VisitorAsUser = 访客作为 UserVisitor;
       if (visitorAsUser!= null)
           返回 this.Accept(UserVisitor);
   }
   

SystemVisitor 仍然对您的 UserThing 一无所知，并且现有的 SystemVisitor 无法访问它们，但您的 UserVisitor 可以。