C# DynamicMethod.Invoke方法代码示例

        static void Main(string[] args)
        {
            var dynMethod = new DynamicMethod("HelloMethod", null, null);
            ILGenerator gen = dynMethod.GetILGenerator();
            gen.EmitWriteLine("Hello world");
            gen.Emit(OpCodes.Ret);
            dynMethod.Invoke(null, null);

            AssemblyName name = new AssemblyName("DynamicAssembly");
            AssemblyBuilder assemblyBuilder= AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave);

            ModuleBuilder moduleBuilder= assemblyBuilder.DefineDynamicModule("DynamicModule", "DynamicAssembly.dll");
            TypeBuilder tb= moduleBuilder.DefineType("HelloClass", TypeAttributes.Class|TypeAttributes.Public);

            MethodBuilder mb= tb.DefineMethod("PrintHello", MethodAttributes.Public, null, new Type[]{typeof(string)});

            ILGenerator myMethodIL = mb.GetILGenerator();
            myMethodIL.Emit(OpCodes.Ldstr, "Hello ");
            myMethodIL.Emit(OpCodes.Ldarg_1);
            MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
            myMethodIL.Emit(OpCodes.Call, concatMethod);
            MethodInfo writeMethod = typeof(Console).GetMethod("Write", new Type[] { typeof(string) });
            myMethodIL.Emit(OpCodes.Call, writeMethod);
            myMethodIL.Emit(OpCodes.Ret);

            Type helloType=tb.CreateType();

            object helloObj= Activator.CreateInstance(helloType);
            MethodInfo helloInstanceMethod= helloType.GetMethod("PrintHello", new Type[] { typeof(string) });
            helloInstanceMethod.Invoke(helloObj, new object[]{ "Antonio" });

            assemblyBuilder.Save("DynamicAssembly.dll");
        }

        static void Main(string[] args)
        {
            var division = new DynamicMethod(
                    "Division",
                    typeof(double),  // Return type
                    new[] {
                        typeof(int), // Parameter: a
                        typeof(int)  // Parameter: b
                    },
                    typeof(Program).Module
                );

            ILGenerator il = division.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Div);
            il.Emit(OpCodes.Ret);

            var result =
                division.Invoke(null, new object[] { 6, 2 });

            Console.WriteLine(result);
            var divideIt =
                (DivideInvoker)division.CreateDelegate(typeof(DivideInvoker));

            var divideItResult = divideIt(4, 0);

            Console.WriteLine(divideItResult);
        }

		public void TestCall2()
		{
			var parameters = new[] { typeof(int), typeof(int) };

			var dm = new DynamicMethod("soma", typeof(int), parameters);

			var gen = dm.GetILGenerator();

			gen.DeclareLocal (typeof(Math));
			var ctor = typeof(Math).GetConstructors () [0];

			gen.Emit (OpCodes.Newobj, ctor);
			gen.Emit (OpCodes.Stloc, 0);
            gen.Emit (OpCodes.Ldobj, 0);

			//gen.Emit(OpCodes.Ldarg_0);
			//gen.Emit(OpCodes.Ldarg_1);
			//var soma = GetType ().GetMethod ("Soma");

			//gen.EmitCall (OpCodes.Callvirt, soma, new Type[] {  });

			gen.Emit (OpCodes.Ldc_I4, 2);

			gen.Emit(OpCodes.Ret);

			var result = dm.Invoke(null, new object[] { 1, 1 });

			//var func = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));

			Assert.AreEqual (2, result);
		}          

        /// <summary>
        /// need to invoke a base class method that is over ridden by the subclass?
        /// no fear use this extension shamelessly taken from http://www.simplygoodcode.com/2012/08/invoke-base-method-using-reflection.html
        /// 
        /// </summary>
        /// <param name="methodInfo"></param>
        /// <param name="targetObject"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static object InvokeNotOverride(this MethodInfo methodInfo, object targetObject, params object[] arguments)
        {
            var parameters = methodInfo.GetParameters();

            if (parameters.Length == 0)
            {
                if (arguments != null && arguments.Length != 0)
                    throw new Exception("Arguments cont doesn't match");
            }
            else
            {
                if (parameters.Length != arguments.Length)
                    throw new Exception("Arguments cont doesn't match");
            }

            Type returnType = null;
            if (methodInfo.ReturnType != typeof(void))
            {
                returnType = methodInfo.ReturnType;
            }

            var type = targetObject.GetType();
            var dynamicMethod = new DynamicMethod("", returnType,
                    new Type[] { type, typeof(Object) }, type);

            var iLGenerator = dynamicMethod.GetILGenerator();
            iLGenerator.Emit(OpCodes.Ldarg_0); // this

            for (var i = 0; i < parameters.Length; i++)
            {
                var parameter = parameters[i];

                iLGenerator.Emit(OpCodes.Ldarg_1); // load array argument

                // get element at index
                iLGenerator.Emit(OpCodes.Ldc_I4_S, i); // specify index
                iLGenerator.Emit(OpCodes.Ldelem_Ref); // get element

                var parameterType = parameter.ParameterType;
                if (parameterType.IsPrimitive)
                {
                    iLGenerator.Emit(OpCodes.Unbox_Any, parameterType);
                }
                else if (parameterType == typeof(object))
                {
                    // do nothing
                }
                else
                {
                    iLGenerator.Emit(OpCodes.Castclass, parameterType);
                }
            }

            iLGenerator.Emit(OpCodes.Call, methodInfo);
            iLGenerator.Emit(OpCodes.Ret);

            return dynamicMethod.Invoke(null, new object[] { targetObject, arguments });
        }

	public void GetTokenFor_String () {
		DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(string), Type.EmptyTypes, typeof(DynamicILInfoTest), false);
		DynamicILInfo il = dm.GetDynamicILInfo();
 
		byte[] code = { 0x00, 0x72, 0x01, 0x00, 0x00, 0x70, 0x2a };
		int token0 = il.GetTokenFor("ABCD");
		PutInteger4(token0, 0x0002, code);
		il.SetCode(code, 8);
 
		var res = dm.Invoke(null, null);
		Assert.AreEqual ("ABCD", res);
	}

		/// <summary>
		/// Creates a new 2D array instance of ITile using the default Terraria.Tile implementation.
		/// 
		/// This cannot be compiled in the OTAPI solution as the Terraria.Tile will not implement 
		/// ITile at compile time.
		/// </summary>
		/// <returns>A 2D ITile array instance</returns>
		private static ITile[,] GetNewTileCollection()
		{
			var dm = new DynamicMethod("GetNewTileCollection", typeof(ITile[,]), null);
			var processor = dm.GetILGenerator();

			processor.Emit(OpCodes.Ldsfld, typeof(global::Terraria.Main).GetField("maxTilesX"));
			processor.Emit(OpCodes.Ldsfld, typeof(global::Terraria.Main).GetField("maxTilesY"));
			processor.Emit(OpCodes.Newobj, typeof(global::Terraria.Tile[,]).GetConstructors().Single(x => x.GetParameters().Length == 2));
			processor.Emit(OpCodes.Ret);

			return (ITile[,])dm.Invoke(null, null);
		}

        public static void Main(string[] args)
        {
            DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(void),
                                                 new Type[] { }, typeof(HelloWorldLCG), false);

            ILGenerator il = dm.GetILGenerator();
            il.Emit(OpCodes.Ldstr, "hello, world");
            il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine",
                    new Type[] { typeof(string) }));
            il.Emit(OpCodes.Ret);

            dm.Invoke(null, null);
        }

	public void GetTokenFor_Type () {
		DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(Type), Type.EmptyTypes, typeof(DynamicILInfoTest), false);
		DynamicILInfo il = dm.GetDynamicILInfo();

		byte[] code = { 0x00, 0xd0, 0x01, 0x00, 0x00, 0x70, 0x28, 0x04, 0x00, 0x00, 0x0a, 0x00, 0x2a };
		int token0 = il.GetTokenFor(typeof (int).TypeHandle);
		int token1 = il.GetTokenFor(typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }).MethodHandle);
		PutInteger4(token0, 0x0002, code);
		PutInteger4(token1, 0x0007, code);
		il.SetCode(code, 8);
 
		var res = dm.Invoke(null, null);
		Assert.AreEqual (typeof (int), res);
	}

	public void GetTokenFor_Method () {
		DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(string), Type.EmptyTypes, typeof(DynamicILInfoTest), false);
		DynamicILInfo il = dm.GetDynamicILInfo();

		// ldstr "ABCD"; call string::ToLower (); ret
		byte[] code = { 0x00, 0x72, 0x01, 0x00, 0x00, 0x70, 0x28, 0x04, 0x00, 0x00, 0x0a, 0x00, 0x2a };
		int token0 = il.GetTokenFor("ABCD");
		int token1 = il.GetTokenFor(typeof(string).GetMethod("ToLower", Type.EmptyTypes).MethodHandle);
		PutInteger4(token0, 0x0002, code);
		PutInteger4(token1, 0x0007, code);
		il.SetCode(code, 8);
 
		var res = dm.Invoke(null, null);
		Assert.AreEqual ("abcd", res);
	}

        public void Do()
        {
            var parameters = new[] { typeof(int), typeof(int) };

            var dm = new DynamicMethod("soma", typeof(int), parameters);

            var gen = dm.GetILGenerator();

            gen.Emit(OpCodes.Ldc_I4, 1);
            gen.Emit(OpCodes.Ldc_I4, 1);
            gen.Emit(OpCodes.Add);
            gen.Emit(OpCodes.Ret);

            var result = dm.Invoke(null, new object[] { 1, 1 });

            Assert.AreEqual(2, result);
        }   

        public void TwoPlusTwoWithParameters_Reference()
        {
            // arrange
            var dm = new DynamicMethod("SomeName", typeof(int), new[] { typeof(int), typeof(int) });

            var ilgen = dm.GetILGenerator();
            ilgen.Emit(OpCodes.Ldarg_0);
            ilgen.Emit(OpCodes.Ldarg_1);
            ilgen.Emit(OpCodes.Add);
            ilgen.Emit(OpCodes.Ret);

            // act
            var result = dm.Invoke(null, new object[] { 2, 2 });

            // assert
            result.Should().Be(4);
        }

        public void DeclareLocal_EmitsProvidedInstructions(byte value)
        {
            var method = new DynamicMethod("Test", typeof(byte), new Type[0]);
            var generator = method.GetILGenerator();

            var subject = new ILGeneratorWrapper(generator);

            // Act
            var local = subject.DeclareLocal(typeof(byte), false);
            subject.Emit(OpCodes.Ldc_I4_S, value);
            subject.Emit(OpCodes.Stloc, local);
            subject.Emit(OpCodes.Ldloc, local);
            subject.Emit(OpCodes.Ret);
            byte result = (byte)method.Invoke(null, new object[0]);

            // Assert
            Assert.AreEqual(value, result);
        }

        public void EmitBranch_EmitsProvidedInstructions(int value)
        {
            var method = new DynamicMethod("Test", typeof(int), new Type[0]);
            var generator = method.GetILGenerator();

            var subject = new ILGeneratorWrapper(generator);

            // Act
            var label = subject.DefineLabel();
            subject.Emit(OpCodes.Ldc_I4, value);
            subject.Emit(OpCodes.Br, label);
            subject.Emit(OpCodes.Ldc_I4, 123);
            subject.MarkLabel(label);
            subject.Emit(OpCodes.Ret);
            int result = (int)method.Invoke(null, new object[0]);

            // Assert
            Assert.AreEqual(value, result);
        }

        public void GenerateFilterIlTest()
        {
            // Arrange
            ExpressFormsFilterText target = new ExpressFormsFilterText();
            DynamicMethod method = new DynamicMethod("Wow", typeof(bool), new Type[] { typeof(TestClass2) });
            ILGenerator generator = method.GetILGenerator();
            PropertyInfo property = typeof(TestClass2).GetProperty("Text");
            Dictionary<string, string> thisFilter = new Dictionary<string, string>() { { "filterMode", Convert.ToString(TestContext.DataRow["FilterMode"]) }, { "filterText", Convert.ToString(TestContext.DataRow["FilterText"]) } };
            TestClass2 argument = new TestClass2() { Text = Convert.ToString(TestContext.DataRow["ValueToMatch"]) };

            // Act
            target.GenerateFilterIl(generator, thisFilter, property);
            // The method would eventually return true if it didn't encounter a reason to return false.
            generator.EmitReturnTrue();
            object objResult = method.Invoke(null, new[] { argument });
            bool result = (bool)objResult;

            // Assert
            bool expected = Convert.ToBoolean(TestContext.DataRow["Result"]);
            Assert.AreEqual(expected, result);
        }

        public static int Execute(TreeNode root)
        {
            DynamicMethod method = new DynamicMethod("Exec_" + i++,
                                                     typeof(int),
                                                     new Type[] { },
                                                     typeof(Program).Module);

            ILGenerator generator = method.GetILGenerator();

            ILStack = new Stack<MathOpOrVal>();
            BuildStack(ILStack, root);

            while (ILStack.Count > 0)
            {
                MathOpOrVal mv = ILStack.Pop();
                if (mv.Op != null)
                {
                    switch (mv.Op)
                    {
                        case MathOp.Add:
                            Console.WriteLine("add");
                            generator.Emit(OpCodes.Add);
                            break;

                        case MathOp.Sub:
                            Console.WriteLine("sub");
                            generator.Emit(OpCodes.Sub);
                            break;

                        case MathOp.Mul:
                            Console.WriteLine("mul");
                            generator.Emit(OpCodes.Mul);
                            break;

                        case MathOp.Div:
                            Console.WriteLine("div");
                            generator.Emit(OpCodes.Div);
                            break;
                    }
                }
                else
                {
                    Console.WriteLine("ldc " + mv.Value.Value);
                    generator.Emit(OpCodes.Ldc_I4, mv.Value.Value);
                }
            }

            generator.Emit(OpCodes.Ret);

            return (int)method.Invoke(null,
                                      BindingFlags.ExactBinding,
                                      null,
                                      new object[] { },
                                      null);
        }