@ OP: Wow, that code you found is horrible :D!

benryves' observation about function overloading is the best to solve this particular example, since the caller is not calling using a base class reference.

The "as" keyword is much better than comparing type names if you DO get stuck with a caller-side base class reference.

Interfaces and (to a certain extent) extension methods can provide slightly different and possibly more powerful ways of getting things like this done with fewer lines of code than the Visitor example.

Reflection and MethodInfo.Invoke() are very slow compared to normal function calls. Actually MethodInfo.Invoke() is used by VB.NET to implement dynamic binding. So the it may actually perform worse than if-else.

The right solution is to use Dictionary and delegates. Delegates are about the same speed as interface method calls. And to allow casting to derived event data types, generic and a wrapper class are needed. It is roughly like this:

class Dispatcher
{
Dictionary<Type, HandlerBase> dict;
public void Register<T>(Action<T> handler) where T: EventData
{
dict.Add(typeof(T), new Handler<T>(handler));
}
public void Dispatch(EventData data)
{
dict[data.GetType()].Invoke(data);
}
abstract class HandlerBase
{
public abstract void Invoke(EventData data);
}
class Handler<T> : HandlerBase where T: EventData
{
Action<T> handler;
public override void Invoke(EventData data)
{
handler((T)data);
}
}
}