C#

class MethodInfoCollection: List<MethodInfo> { ... }<br />
<br />
Dictionary<Type, MethodInfoCollection> m_Methods; ...etc

delegate void SpecificDelegate();<br />
<br />
Dictionary<string, SpecificDelegate> m_MSILMethods;

<code>public static void CallMethod(string MethodName)
{

   m_MSILMethods[MethodName].Invoke();
   // m_MSILMethods[MethodName].Invoke(); should act like this:
   // [pseudocode]
   // Call ObjectA.MethodName;
   // Call ObjectB.MethodName;
   // Call ObjectC.MethodName;
   // ...and so on. instead of having a slow MethodInfo.Invoke() call in a foreach loop each time.

}
</code>

<code>DynamicMethod m_MSILMethod;
ILGenerator m_ILGenerator;

foreach (string m_InterfaceMethod in m_InterfaceMethods)
{

[...].
m_MSILMethod = new DynamicMethod(String.Format("Managed{0}", m_InterfaceMethod), null, null, typeof(MyManager));

m_ILGenerator = m_MSILMethod.GetILGenerator();

   foreach (Type m_Type in m_TypeExecutionOrder)
   {

      foreach (MethodInfo m_Method in m_Methods[m_Type])
      {

         if (m_Method.Name == m_InterfaceMethod)
         {
            m_ILGenerator.Emit(OpCodes.Ldarg_0); // the method is not static.
            m_ILGenerator.Emit(OpCodes.Call, m_Method); // the actual call to the method
         }

      }
   }

m_ILGenerator.Emit(OpCodes.Ldnull);
m_ILGenerator.Emit(OpCodes.Ret);


// Once the delegate is created, Emit() won't add more instructions, so the DynamicMethod is "done".
m_MSILMethods.Add(m_InterfaceMethod, (SpecificDelegate)m_MSILMethod.CreateDelegate(typeof(SpecificDelegate)));
}</code>