C#

Roberto Collina wrote:

By removing ldnull I get a unhandled AccessViolationException, exactly where DynamicMethod.Invoke is called.
"Attempted to read or write protected memory. This is often an indication that other memory is corrupt."

Roberto Collina wrote:

Edit 2: I guess Ldnull is needed since the return value is of type "void".

.method public hidebysig instance void  TestMethod() cil managed
{
  // Code size       13 (0xd)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldstr      "Hello"
  IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_000b:  nop
  IL_000c:  ret
} // end of method Program::TestMethod

public class Program
    {
        delegate void MyDelegate();
        public void TestMethod(){Console.WriteLine("Hello");}
        public static void Main()
        {
            Program p = new Program();
            MethodInfo methodInfo = p.GetType().GetMethod("TestMethod");
            DynamicMethod dynMethod = new DynamicMethod("DynTestMethod", null, null, typeof(Program));
            ILGenerator gen = dynMethod.GetILGenerator();
            gen.Emit(OpCodes.Ldarg_0);
            gen.Emit(OpCodes.Call, methodInfo);
            //gen.Emit(OpCodes.Ldnull); // If you uncomment, you'll get InvalidProgramException
            gen.Emit(OpCodes.Ret);
            MyDelegate d = (MyDelegate)dynMethod.CreateDelegate(typeof(MyDelegate));
            d.Invoke();
        }
    }

<code>
			gen.Emit(OpCodes.Ldarg_0);
			gen.Emit(OpCodes.Call, methodInfo);
			gen.Emit(OpCodes.Ldarg_0);
			gen.Emit(OpCodes.Call, methodInfo);
</code>

<code>
	public class Program
	{
		delegate void MyDelegate();
		public void TestMethod() { Console.WriteLine("Hello"); }
		public void TestMethod2() { Console.WriteLine("hey"); }
		public static void Main()
		{
			Program p = new Program();
			MethodInfo methodInfo = p.GetType().GetMethod("TestMethod");
			MethodInfo methodInfo2 = p.GetType().GetMethod("TestMethod2");

			DynamicMethod dynMethod = new DynamicMethod("DynTestMethod", 
                            null, null, typeof(Program));

			ILGenerator gen = dynMethod.GetILGenerator();

			gen.Emit(OpCodes.Ldarg_0);
			gen.Emit(OpCodes.Call, methodInfo);

			//IL instruction missing here
			gen.Emit(OpCodes.Call, methodInfo2); //Most likely to produce the exception.

			gen.Emit(OpCodes.Ret);

			MyDelegate d = (MyDelegate)dynMethod.CreateDelegate(typeof(MyDelegate));
			d.Invoke();
			Console.ReadLine();

		}
	}
</code>

<code>
.method void ManagedProcessInput 
{
	ldarg_0
	call void UserInterface.ProcessInput()
	call void UserInterfaceEditor.ProcessInput()
	ret
}
</code>

<code>
interface IMyInterface
{
   void Run();
}

class MyObject : IMyInterface
{
   [ctor / dtor]
   public void Run()
   {
      [impl. here]
   }
}
</code>

delegate void MyDelegate(Program p);

DynamicMethod dynMethod = new DynamicMethod("DynTestMethod", null, new Type[] { typeof(Program) }, typeof(Program)); // Notice typeof(Program) added to the list of parameter types

d.Invoke(p); // p is an instance of Program

class Program
{
   ...
   static void DynMethod(Program p)
   {
      p.TestMethod();
      p.TestMethod2();
   }
}

DynamicMethod m_MSILMethod;
ILGenerator m_ILGenerator;

foreach (string m_InterfaceMethod in m_InterfaceMethods)
{

[...].
m_MSILMethod = new DynamicMethod(String.Format("Managed{0}", m_InterfaceMethod), null, m_TypeExecutionOrder.ToArray(), typeof(MyManager)); //assuming m_TypeExecutionOrder is List<Type>

m_ILGenerator = m_MSILMethod.GetILGenerator();

int index = 0;

   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, index); // note the dynamic changing of index according to the type
            m_ILGenerator.Emit(OpCodes.Call, m_Method); // the actual call to the method
         }

      }

      index++
   }

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)));

delegate void SpecificDelegate(MyObject obj1, YourObject obj2, othertypes...);

MyObject obj1 = new MyObject();
YourObject obj2 = new YourObject();
m_InterfaceMethod.Invoke(obj1, obj2);

<code>  delegate void PlugInMethodDelegate(object[] Instances);

                 /* ... */

        m_MSILMethod = /* The dynamic method is here  */
               new DynamicMethod(String.Format("Managed{0}", m_InterfaceMethod),
                    null, m_Params.ToArray(), typeof(PlugInManager));


	//Gives this error: Error binding to target method.
        PlugInMethodDelegate m_Delegate = (PlugInMethodDelegate)m_MSILMethod.CreateDelegate
                                                         (typeof(PlugInMethodDelegate));

</code>

PlugInManager: [ERROR] CreateMSILMethods(): Error binding to target method.
   at System.Delegate.CreateDelegate(Type type, Object target, RuntimeMethodHandle method)
   at System.Reflection.Emit.DynamicMethod.CreateDelegate(Type delegateType)
   at Dreams.PlugInManager.CreateMSILMethodsLookup() in C:\xxxx.cs:line 1280

<code>    List< Type > m_Params;
</code>

<code>.method void ManagedPreRender(UserInterface, UserInterfaceEditor) 
{
	ldarg 0		// param "UserInterface"
	call void UserInterface::PreRender()

	ldarg 1		// param "UserInterfaceEditor"
	call void UserInterfaceEditor::PreRender()

	ret
}
</code>

DataGrid.DataSource = DataSet.Tables["Table1"].DefaultView;<br />
ListSortDirection sortDirection = new ListSortDirection();<br />
sortDirection.Equals("Ascending");<br />
DataGrid.Sort(Column1, sortDirection);