There is a well known design pattern in the Object Oriented world: The Visitor pattern.
This pattern, among other things, allows to extend an object without actually modifying it. It is fairly easy to implement in any good OO language such as C++, Java or C#.
However, there is a problem with the implementation of this pattern, or rather an implementation limitation. It requires the base interface or abstract class for all visitors to define at most one method for each type that may visit it. This is not a problem by itself, but it requires to modify the visitor base each time you add a new type. The best way to do this would be to call the appropriate method based on the caller type.
.NET provides that kind of behavior through reflection, as it is possible to find a method based on its parameters at runtime.
I decided to try this out with the C# 2.0 and its generics :)
Here what I came up with :
public interface IOperand
{
IOperand Accept(Visitor visitor, IOperand right);
}
public class Operand< T> : IOperand
{
private T _value;
public Operand(T value)
{
_value = value;
}
public IOperand Accept(Visitor v, IOperand right)
{
return v.Visit(this, right);
}
public T Value
{
get { return _value; }
}
public override string ToString()
{
return string.Format("{0} ({1})", _value, GetType());
}
}
This is the definition of an operand, which is used in a abstract machine to perform operations on abstract types. This class is generic, I did not want to implement all the possible types.
Then here is the visitor :
public class Visitor
{
public virtual IOperand Visit(IOperand left, IOperand right)
{
MethodInfo info = GetType().GetMethod("Visit", new Type[] { left.GetType(), right.GetType() });
if (info != null && info.DeclaringType != typeof(Visitor))
return info.Invoke(this, new object[] { left, right }) as IOperand;
Console.WriteLine("Operation not supported");
return null;
}
}
This method search in the current type all methods named "Visit" that take the actual type of the parameters left and right and tries to match a method with it. Also, to avoid looping through the same method we're in since it's matching everything, there is a test for the type declaring the method.
Now the AdditionVisitor :
public class AdditionVisitor : Visitor
{
public IOperand Visit(Operand<int> value, Operand<int> right)
{
return new Operand<int>(value.Value + right.Value);
}
public IOperand Visit(Operand<int> value, Operand<short> right)
{
return new Operand<int>(value.Value + right.Value);
}
public IOperand Visit(Operand<double> value, Operand<int> right)
{
return new Operand<double>(value.Value + right.Value);
}
}
Which defines a bunch of visitable methods used to add different operations on IOperand-like types.
And finally to use it :
class Program
{
static void Main(string[] args)
{
Operand<int> a = new Operand<int>(21);
Operand<short> b = new Operand<short>(21);
Console.WriteLine(Add(a, b));
}
static IOperand Add(IOperand a, IOperand b)
{
AdditionVisitor addVisitor = new AdditionVisitor();
return a.Accept(addVisitor, b);
}
}
Using this Reflective Visitor, modifying the base visitor class is not needed anymore, which limits the modifications to one class only. Of course, there's room for optimization, for instance by avoiding the method lookup using the System.Reflection namespace, but you get the picture.
Some asked me what could be done in .NET that could not be done in C++, this is an example of it :)