在C＃中不太复杂的Visitor实现

Question

Suppose you have an abstract BaseClass and some derived classes and that you need to visit a List<BaseClass> with a Visitor . The code would be:

class Visitor
{
    public void Visit(Derived1 visitable) { /*do something*/ }
    public void Visit(Derived2 visitable) { /*do something*/ }
    public void Visit(Base visitable) { thrown new InvalidOperationException(); }
    //other derivatives
}

class Base
{
    public virtual void Accept(Visitor visitor) { visitor.Visit(this); }
}

class Derived1 : Base
{
    //override is mandatory to have Visit(Derived1 visitable) called
    public override void Accept(Visitor visitor) { visitor.Visit(this); }
}

class Derived2 : Base
{
    //override is mandatory to have Visit(Derived2 visitable) called
    public override void Accept(Visitor visitor) { visitor.Visit(this); }
}

Then you can use all this stuff in a method like:

var baseClassList = new List<BaseClass>();
//fill baseClassList somehow

var visitor = new Visitor();

foreach(var visitable in baseClassList)
    visitable.Accept(visitor);

I think this is a bit too much for a simple dispatching of some operations on different derived classes.

Also, it is counter-intuitive that the chain starts from calling Accept and not Visit .

Also, if you add a new Derived3 class, you always have to do 2 things: a new overload in the Visitor AND the override of the Accept method in the new derived class. Often you forget the second point, getting a runtime error, and other annoying things.

I'm looking for some simpler and less verbose and more secure implementation of a Visitor pattern in C#. Is it possible?

Answer 1

Given 2 hypotheses:

1. You can use C# 4.0 or more recent
2. BaseClass is abstract and there isn't a "default" behavior for BaseClass (ie, the Visitor has a different specific behavior on EVERY derived)

I found a solution:

class DynamicVisitor
{
    public void Visit(BaseClass b)
    {
        Visit((dynamic)b);
    }

    public void Visit(Derived1 b) { /*do something*/ }

    public void Visit(Derived2 b) { /*do something*/ }
}

And you use it this way:

var baseClassList = new List<BaseClass>();
//fill baseClassList somehow

var visitor = new Visitor();

foreach(var visitable in baseClassList)
    visitor.Visit(visitable);

This way, you don't need any Accept method, nor its overrides on the visited classes. You only need to write the overloads on the Visitor . The overload Visit(BaseClass b) ensures that any passed parameter derives at least from the BaseClass , but the dynamic cast makes the Visitor to choose the specific overload at runtime. Obviously, if an instance is exactly of type BaseClass , you have an infinite recursive call of Visit(Base b) , and that's because I supposed that BaseClass is abstract: this way you cannot have an instance of that exact type.

---

EDIT:

I made some performance tests with this approximate load:

1. A BaseClass and 17 DerivedClasses implementing an IVisitable interface;
2. a list with a milion instances of BaseClass to visit;
3. a ClassicVisitor and a DynamicVisitor both implementing an IVisitor interface;
4. All the Accept methods call only the Visit method and all the Visit methods are empty, to maximize the measured difference in time.
5. Time measured with a Stopwatch in both Debug and Release mode.

Result: the DynamicVisitor is more than 10 times slower (~5/600ms against ~50ms).

So, this solution is suitable for contexts in which you have a small amount of calls to make on the visitor.