Dynamic Dispatching

• Download source code plus unit tests - 14 Kb

Introduction

Sometimes you come across a design problem that cries out for using the Visitor pattern, but you just cannot use it because new Visitors are to be loaded at runtime, for example from plug-ins. Other times, you have a situation where the action chosen is parameterized over two types instead of one - and again you cannot use a classical Visitor pattern. This article presents a solution to both kind of scenarios. Included with the source is a quite complete suite of unit tests. Beware that in order to build the source, you need the PowerCollections library from Wintellect - a library which I could not live without, cheers to the folks at Wintellect - and MbUnit.

The classical Visitor pattern, its motivation, its benefits

Let's look at the classical Visitor pattern. Say you want to implement a model of mathematical expressions as a composite:

public interface IExpression
{
}
public class UnaryFunction : IExpression
{
    readonly string mName;
    readonly IExpression mArgument;
    public UnaryFunctionNode(string name, IExpression argument)
    {
        mName= name;
        mArgument= argument;
    }
    public string Name
    {
        get { return mName; }
    }
    public IExpression Argument
    {
        get { return mArgument; }
    }
}
public class Addition : IExpression
{
    readonly IExpression mLeftHandSide;
    readonly IExpression mRightHandSide;
    public Addition(IExpression lhs, IExpression rhs)
    {
        mLeftHandSide= lhs;
        mRightHandSide= rhs;
    }
    public IExpression LeftHandSide
    {
        get { return mLeftHandSide; }
    }
    public IExpression RightHandSide
    {
        get { return mRightHandSide; }
    }
}
public class Number : IExpression
{
    readonly int mValue;
    public Number(int value)
    {
        mValue= value;
    }
    public int Value
    {
        get { return mValue; }
    }
}

IExpression exp= new UnaryFunction("sin", 
                 new Addition(new Number(30), new Number(15)));

public class ExpressionPrinter
{
    public void Print(IExpression expression)
    {
        if (expression is Number)
        {
            Console.Write(expression as Number).Value);
        }
        else if (expression is Addition)
        {
            Addition add= expression as Addition;
            Print(add.LeftHandSide);
            Console.Write('+');
            Print(add.RightHandSide);
        }
        else if (expression is UnaryFunction)
        {
            UnaryFunction fun= expression as UnaryFunction;
            Console.Write(fun.Name);
            Console.Write('(');
            Print(fun.Argument);
            Console.Write(')');
        }
        else
            throw new ArgumentException("Unknown type.")
    }
}

public interface IExpression
{
    void Accept(IExpressionVisitor visitor);
}
public interface IExpressionVisitor
{
    void Visit(UnaryFunction function);
    void Visit(Addition addition);
    void Visit(Number number);
}
public class UnaryFunction : IExpression
{
    readonly string mName;
    readonly IExpression mArgument;
    public UnaryFunctionNode(string name, IExpression argument)
    {
        mName= name;
        mArgument= argument;
    }
    public string Name
    {
        get { return mName; }
    }
    public IExpression Argument
    {
        get { return mArgument; }
    }
    public void Accept(IExpressionVisitor visitor)
    {
        visitor.Visit(this);
    }
}
public class Addition : IExpression
{
    readonly IExpression mLeftHandSide;
    readonly IExpression mRightHandSide;
    public Addition(IExpression lhs, IExpression rhs)
    {
        mLeftHandSide= lhs;
        mRightHandSide= rhs;
    }
    public IExpression LeftHandSide
    {
        get { return mLeftHandSide; }
    }
    public IExpression RightHandSide
    {
        get { return mRightHandSide; }
    }
    public void Accept(IExpressionVisitor visitor)
    {
        visitor.Visit(this);
    }
}
public class Number : IExpression
{
    readonly int mValue;
    public Number(int value)
    {
        mValue= value;
    }
    public int Value
    {
        get { return mValue; }
    }
    public void Accept(IExpressionVisitor visitor)
    {
        visitor.Visit(this);
    }
}
public class ExpressionPrinter : IExpressionVisitor
{
    public void Visit(UnaryFunction function)
    {
        Console.Write(function.Name);
        Console.Write('(');
        function.Argument.Accept(this);
        Console.Write(')');
    }
    public void Visit(Addition addition)
    {
        addition.LeftHandSide.Accept(this);
        Console.Write('+');
        addition.RightHandSide.Accept(this);
    }
    public void Visit(Number number)
    {
        Console.Write(number.Value);
    }
}

A common variation is to create a class deriving from IExpressionVisitor and implement all Visit() overloads with an empty body. The drawback here is that you loose the luxury of having the compiler tell you when you forget to treat a specific implementation of IExpression in any of your visitors. Also note that whenever you add new implementation of IExpression, you need to adapt IExpressionVisitor and all its implementors. In other words, a precondition for using the visitor pattern is that you know that your class hierarchy won't change much or at all after a certain time of stabilizing.

Situations where you cannot use the visitor pattern

There are several situations where you just cannot use the visitor pattern, however much you would want to:

• The most simplistic problem is if some of the types you want to operate on are not under your control, i.e., you cannot add the Accept() method to them and cannot add a common interface to their interface list. Imagine for example that your code for printing does something really fancy, and at some point you realize you'd like to re-use that functionality for regular ints or floats. It's a cheesy example, and you obviously could extract the fancy functionality into some other class, but you get the point. It could be also that you want your operational code to work on several types from a third-party library and that library did not implement the visitor pattern.
• Another scenario is if new visitables and new visitors should be added at runtime, eg, being loaded from plug-ins. You could not allow a plug-in author to add a new implementation of IExpression, say, Subtraction, and provide the code for printing it if you chose to use the visitor pattern. This is probably the most common situation where you just cannot use the visitor pattern despite its significant benefits.
• The third problematic scenario is if you'd like your visitor to visit combinations of visitables. Imagine for example an application for converting many file formats into many others. You'd probably have an interface IImporter with plenty of implementors and another one IExporter with again a bunch of implementors. For many pairs of import and export formats you want to do exactly the same, but there are a few special cases of specific combinations where you need to perform some extra steps. Now you'd probably want to avoid introducing a bowl of if-else-spaghetti and use a visitor, but again you can't.

Using dynamic method dispatching instead of a visitor pattern

In all three scenarios mentioned, it would be nice to find a solution that gives at least some of the benefits of the visitor pattern. The four main benefits were:

• Avoiding the complexity of many conditionals for dispatching to the concrete type.
• Clean separation of treating individual concrete types.
• No duplication of dispatching code.
• Forgetting to implement an operation for a specific concrete type is caught at compile-time instead of run-time.

public class Dispatcher
{
    readonly Dictionary<typeof(T), Action<T>> mRegistry= 
                 new Dictionary<typeof(T), Action<T>>();
    
    public void Register<T>(Action <T> action)
    {
        mRegistry[typeof(T)]= action;
    }
    public void Visit<T>(T visitable)
    {
        Action<T> action= mRegistry[typeof(T)];
        action(visitable);
    }
}

readonly Dictionary<object, object> mRegistry = 
               new Dictionary<object, object>();

delegate void UnaryDynamicMethod(object visitable);

public void Register<T>(Action<T> action)
{
    mRegistry[typeof(T)]= (UnaryDynamicMethod)action;
}
public void Visit(object visitable)
{
    UnaryDynamicMethod visitorMethod = 
        mRegistry[visitable.GetType()] as UnaryDynamicMethod;
    visitorMethod(visitable);
}

We want to create a method at run-time, but to save us emitting more intermediate language (IL) code instructions than necessary, we will put the actual hard work into a regular method which we then will call from our dynamically created method:

readonly Dictionary<object, Delegate> mDelegates = 
                 new Dictionary<object, Delegate>();
void Handle<T>(object visitable)
{
    Action<T> action = (Action<T>) mDelegates[typeof (T)];
    action.Invoke((T) visitable);
}

Now, let's move to the Register() method. First of all we need to be able to get the parameter type of the passed visitor method; we will later need it inside an array, so let's create one right away:

public void Register<T>(Action<T>action)
{
    ParameterInfo[] parameterInfo = action.Method.GetParameters();
    Type[] originalParameterTypes = new Type[1];
    originalParameterTypes[0] = parameterInfo[0].ParameterType;

    mDelegates[originalParameterTypes[0]] = action;

    Type[] dynamicParameterTypes= new Type[2];
    dynamicParameterTypes[0]= this.GetType();
    dynamicParameterTypes[1]= typeof(object);
    DynamicMethod method = new DynamicMethod(string.Empty, typeof(void), 
                           dynamicParameterTypes, this.GetType());

    ILGenerator generator = method.GetILGenerator();
    generator.Emit(OpCodes.Ldarg, 0);
    generator.Emit(OpCodes.Ldarg, 1);
    MethodInfo handleMethod = GetType().GetMethod("Handle", 
               BindingFlags.Instance | BindingFlags.NonPublic);
    handleMethod = handleMethod.MakeGenericMethod(originalParameterTypes);
    generator.EmitCall(OpCodes.Call, handleMethod, null);
    generator.Emit(OpCodes.Ret);

    mRegistry[originalParameterTypes[0]] = 
      method.CreateDelegate(typeof (UnaryDynamicMethod), this);
}

public interface IExpression
{
}
public class UnaryFunction : IExpression
{
    readonly string mName;
    readonly IExpression mArgument;
    public UnaryFunctionNode(string name, IExpression argument)
    {
        mName= name;
        mArgument= argument;
    }
    public string Name
    {
        get { return mName; }
    }
    public IExpression Argument
    {
        get { return mArgument; }
    }
}
public class Addition : IExpression
{
    readonly IExpression mLeftHandSide;
    readonly IExpression mRightHandSide;
    public Addition(IExpression lhs, IExpression rhs)
    {
        mLeftHandSide= lhs;
        mRightHandSide= rhs;
    }
    public IExpression LeftHandSide
    {
        get { return mLeftHandSide; }
    }
    public IExpression RightHandSide
    {
        get { return mRightHandSide; }
    }
}
public class Number : IExpression
{
    readonly int mValue;
    public Number(int value)
    {
        mValue= value;
    }
    public int Value
    {
        get { return mValue; }
    }
}
public class ExpressionPrinter
{
    public void PrintUnaryFunction(UnaryFunction function)
    {
        Console.Write(function.Name);
        Console.Write('(');
        function.Argument.Accept(this);
        Console.Write(')');
    }
    public void PrintAddition(Addition addition)
    {
        addition.LeftHandSide.Accept(this);
        Console.Write('+');
        addition.RightHandSide.Accept(this);
    }
    public void PrintNumber(Number number)
    {
        Console.Write(number.Value);
    }
}

// ... somewhere in the client code:

ExpressionPrinter printer= new ExpressionPrinter()
DynamicActionDispatcher dispatcher= new DynamicActionDispatcher();
dispatcher.AddAction<Number>(printer.PrintNumber);
dispatcher.AddAction<UnaryFunction>(printer.PrintUnaryFunction);
dispatcher.AddActionvAddition>(printer.PrintAddition);

public interface IImporter
{
    void Load(Stream stream);
}
public interface IExporter
{
    void Save(Stream steam);
}
public class CSVImporter : IImporter
{    /* implementation */ }
public class FixedLengthImporter : IImporter
{    /* implementation */ }
public class XmlImporter : IImporter
{    /* implementation */ }
public class CSVExporter : IExporter
{    /* implementation */ }
public class FixedLengthExporter : IExporter
{    /* implementation */ }
public class XmlExporter : IExporter
{    /* implementation */ }

// ... somewhere in the client code:

DynamicActionDispatcher dispatcher= new DynamicActionDispatcher();
dispatcher.AddBinaryAction<CSVImporter, XmlExporter>(handleCSV2Xml);
dispatcher.AddBinaryAction<XmlImporter, CSVExporter>(handleXml2CSV);
dispatcher.OnBinaryTypeNotFound+= delegate(object lhs, object rhs)
{
    IImporter importer= (IImporter) lhs;
    IExporter exporter= (IExporter) rhs;
    // handle the generic case which doesn't need any special processing

};