Can I avoid reflection in this case?
<p>Let's say I have these class hierarchy :</p>

<pre><code>public abstract class Parent {
}

public class A : Parent {
    public void Update() { }
}

public class B : Parent {
    public void Update() { }
}

public class C : Parent {
    public void Update() { }
    public void Update(bool force) { }

}
</code></pre>

<p>As you can see, all descendant of <code>Parent</code> have an Update method, with no parameter.</p>

<p>I want to create an utility class that can work with any kind of <code>Parent</code> object and call <code>Update</code> at the end of the process. I am sure the Update method will be implemented, so I wrote this code :</p>

<pre><code>public class ParentUtilities {
    private static readonly Dictionary&lt;Type, MethodInfo&gt; g_UpdateMethods = new Dictionary&lt;Type, MethodInfo&gt;{
        { typeof(A), typeof(A).GetMethod("Update", new Type[] {})},
        { typeof(B), typeof(B).GetMethod("Update", new Type[] {})},
        { typeof(C), typeof(C).GetMethod("Update", new Type[] {})}
    };

    public static void DoSomething(Parent p)
    {
          CalculateTheMeaningOfTheLife(p);             

          g_UpdateMethods[p.GetType()].Invoke(p, null);
    }
}
</code></pre>

<p>As <strong>I don't have control over the class hierarchy (it's from a 3rd party assembly)</strong>. I can only change the utility class. How can I avoid such tweak ?</p>

<p>As I'm sticked to .Net 3.5 SP1, I can't use dynamic.</p>
