Ejemplo n.º 1
0
        public void AnonHosted()
        {
            DynamicMethod hello = new DynamicMethod("Hello",
                                                    typeof(int),
                                                    new Type[] { typeof(string) });
            ILGenerator helloIL = hello.GetILGenerator();

            helloIL.Emit(OpCodes.Ldc_I4_2);
            helloIL.Emit(OpCodes.Ret);

            HelloInvoker hi =
                (HelloInvoker)hello.CreateDelegate(typeof(HelloInvoker));
            int ret = hi("Hello, World!");

            Assert.AreEqual(2, ret);

            object[] invokeArgs = { "Hello, World!" };
            object   objRet     = hello.Invoke(null, invokeArgs);

            Assert.AreEqual(2, objRet);
        }
Ejemplo n.º 2
0
        [Test]         // bug #78253
        public void DynamicMethodReference()
        {
            DynamicMethod hello = new DynamicMethod("Hello",
                                                    typeof(int),
                                                    new Type[] { typeof(string) },
                                                    typeof(DynamicMethodTest).Module);

            Assert.IsNull(hello.DeclaringType, "#1");

            DynamicMethod write = new DynamicMethod("Write",
                                                    typeof(int),
                                                    new Type[] { typeof(string) },
                                                    typeof(DynamicMethodTest));

            Assert.IsNull(hello.DeclaringType, "#2");

            MethodInfo invokeWrite = write.GetBaseDefinition();

            ILGenerator helloIL = hello.GetILGenerator();

            helloIL.Emit(OpCodes.Ldarg_0);
            helloIL.EmitCall(OpCodes.Call, invokeWrite, null);
            helloIL.Emit(OpCodes.Ret);

            ILGenerator writeIL = write.GetILGenerator();

            writeIL.Emit(OpCodes.Ldc_I4_2);
            writeIL.Emit(OpCodes.Ret);

            HelloInvoker hi =
                (HelloInvoker)hello.CreateDelegate(typeof(HelloInvoker));
            int ret = hi("Hello, World!");

            Assert.AreEqual(2, ret, "#3");

            object[] invokeArgs = { "Hello, World!" };
            object   objRet     = hello.Invoke(null, invokeArgs);

            Assert.AreEqual(2, objRet, "#4");
        }
Ejemplo n.º 3
0
    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This method has a string parameter
        // and an int parameter.
        Type[] helloArgs = { typeof(string), typeof(int) };

        // Create a dynamic method with the name "Hello", a return type
        // of int, and two parameters whose types are specified by the
        // array helloArgs. Create the method in the module that
        // defines the Test class.
        DynamicMethod hello = new DynamicMethod("Hello",
                                                typeof(int),
                                                helloArgs,
                                                typeof(Test).Module);

        // <Snippet2>
        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = { typeof(string) };
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString =
            typeof(Console).GetMethod("WriteLine", writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method.
        ILGenerator il = hello.GetILGenerator();

        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);
        // </Snippet2>

        // <Snippet3>
        // Create a delegate that represents the dynamic method. This
        // action completes the method, and any further attempts to
        // change the method will cause an exception.
        HelloInvoker hi =
            (HelloInvoker)hello.CreateDelegate(typeof(HelloInvoker));
        // </Snippet3>

        // Use the delegate to execute the dynamic method. Save and
        // print the return value.
        int retval = hi("\r\nHello, World!", 42);

        Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
                          retval);

        // Do it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
                          retval);

        // <Snippet4>
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = { "\r\nHello, World!", 42 };
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and ValueType arguments
        // must be boxed.
        object objRet = hello.Invoke(null, invokeArgs);

        Console.WriteLine("hello.Invoke returned {0}", objRet);
        // </Snippet4>
    }