C# ILGenerator.EmitCall方法代码示例

 private static void EmitCallMethod(ILGenerator il, MethodInfo methodInfo)
 {
     if (methodInfo.IsStatic)
         il.EmitCall(OpCodes.Call, methodInfo, null);
     else
         il.EmitCall(OpCodes.Callvirt, methodInfo, null);
 }

 /// <summary>
 ///     Generates method invocation code.
 /// </summary>
 /// <param name="il">IL generator to use.</param>
 /// <param name="isStatic">Flag specifying whether method is static.</param>
 /// <param name="isValueType">Flag specifying whether method is on the value type.</param>
 /// <param name="method">Method to invoke.</param>
 protected static void InvokeMethod(ILGenerator il, bool isStatic, bool isValueType, MethodInfo method)
 {
     if (isStatic || isValueType)
     {
         il.EmitCall(OpCodes.Call, method, null);
     }
     else
     {
         il.EmitCall(OpCodes.Callvirt, method, null);
     }
 }

 public override void BuildAssembly( ILGenerator il )
 {
     System.Type[] types = { typeof(String) };
     if (Format != null && Format.Equals("/")) {
         il.Emit(OpCodes.Ldstr, "\n");
         il.EmitCall(OpCodes.Call, typeof(openABAP.Runtime.Runtime).GetMethod("Write", types), null);
     }
     //push formatted string of output value to stack
     this.Value.PushFormattedString(il);
     il.EmitCall(OpCodes.Call, typeof(openABAP.Runtime.Runtime).GetMethod("Write", types), null);
 }

        public static void GenerateSerializerSwitch(CodeGenContext ctx, ILGenerator il, IDictionary<Type, TypeData> map)
        {
            // arg0: Stream, arg1: object

            var idLocal = il.DeclareLocal(typeof(ushort));

            // get TypeID from object's Type
            var getTypeIDMethod = typeof(Serializer).GetMethod("GetTypeID", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(object) }, null);
            il.Emit(OpCodes.Ldarg_1);
            il.EmitCall(OpCodes.Call, getTypeIDMethod, null);
            il.Emit(OpCodes.Stloc_S, idLocal);

            // write typeID
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldloc_S, idLocal);
            il.EmitCall(OpCodes.Call, ctx.GetWriterMethodInfo(typeof(ushort)), null);

            // +1 for 0 (null)
            var jumpTable = new Label[map.Count + 1];
            jumpTable[0] = il.DefineLabel();
            foreach (var kvp in map)
                jumpTable[kvp.Value.TypeID] = il.DefineLabel();

            il.Emit(OpCodes.Ldloc_S, idLocal);
            il.Emit(OpCodes.Switch, jumpTable);

            ConstructorInfo exceptionCtor = typeof(Exception).GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
            il.Emit(OpCodes.Newobj, exceptionCtor);
            il.Emit(OpCodes.Throw);

            /* null case */
            il.MarkLabel(jumpTable[0]);
            il.Emit(OpCodes.Ret);

            /* cases for types */
            foreach (var kvp in map)
            {
                var type = kvp.Key;
                var data = kvp.Value;

                il.MarkLabel(jumpTable[data.TypeID]);

                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldarg_1);
                il.Emit(type.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, type);

                il.EmitCall(OpCodes.Call, data.WriterMethodInfo, null);

                il.Emit(OpCodes.Ret);
            }
        }

 /// <summary>
 /// 写入类型转换的指令。
 /// </summary>
 /// <param name="generator">IL 的指令生成器。</param>
 /// <param name="inputType">要转换的对象的类型。</param>
 /// <param name="outputType">要将输入对象转换到的类型。</param>
 /// <param name="isChecked">是否执行溢出检查。</param>
 public override void Emit(ILGenerator generator, Type inputType, Type outputType, bool isChecked)
 {
     MethodInfo method = converter.Method;
     if (method.IsStatic && method.GetParametersNoCopy().Length == 1)
     {
         // 没有闭包的静态方法可以直接调用。
         generator.EmitCall(method);
     }
     else
     {
         // 有闭包的静态方法，或实例方法，其参数不能直接写入 IL，因此直接调用 Convert 的 ChangeType 方法。
         generator.EmitCall(changeType.MakeGenericMethod(inputType, outputType));
     }
 }

        private static void WriteGetter(ILGenerator il, Type type, PropertyInfo[] props, FieldInfo[] fields, bool isStatic)
        {
            var loc = type.IsValueType ? il.DeclareLocal(type) : null;
            OpCode propName = isStatic ? OpCodes.Ldarg_1 : OpCodes.Ldarg_2, target = isStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1;
            foreach (var prop in props)
            {
                MethodInfo getter;
                if (prop.GetIndexParameters().Length != 0 || !prop.CanRead || (getter = prop.GetGetMethod(false)) == null) continue;

                var next = il.DefineLabel();
                il.Emit(propName);
                il.Emit(OpCodes.Ldstr, prop.Name);
                il.EmitCall(OpCodes.Call, strinqEquals, null);
                il.Emit(OpCodes.Brfalse_S, next);
                // match:
                il.Emit(target);
                Cast(il, type, loc);
                il.EmitCall(type.IsValueType ? OpCodes.Call : OpCodes.Callvirt, getter, null);
                if (prop.PropertyType.IsValueType)
                {
                    il.Emit(OpCodes.Box, prop.PropertyType);
                }
                il.Emit(OpCodes.Ret);
                // not match:
                il.MarkLabel(next);
            }
            foreach (var field in fields)
            {
                var next = il.DefineLabel();
                il.Emit(propName);
                il.Emit(OpCodes.Ldstr, field.Name);
                il.EmitCall(OpCodes.Call, strinqEquals, null);
                il.Emit(OpCodes.Brfalse_S, next);
                // match:
                il.Emit(target);
                Cast(il, type, loc);
                il.Emit(OpCodes.Ldfld, field);
                if (field.FieldType.IsValueType)
                {
                    il.Emit(OpCodes.Box, field.FieldType);
                }
                il.Emit(OpCodes.Ret);
                // not match:
                il.MarkLabel(next);
            }
            il.Emit(OpCodes.Ldstr, "name");
            il.Emit(OpCodes.Newobj, typeof(ArgumentOutOfRangeException).GetConstructor(new Type[] { typeof(string) }));
            il.Emit(OpCodes.Throw);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="il"></param>
        /// <param name="paramAttr"></param>
        /// <param name="parameterType"></param>
        public override void EmitParameterResolution(ILGenerator il, ParameterAttribute paramAttr, Type parameterType)
        {
            ProviderDependencyAttribute attr = (ProviderDependencyAttribute) paramAttr;
            MethodInfo getHeadOfChain = GetPropertyGetter<IBuilderContext>("HeadOfChain", typeof (IBuilderStrategy));
            MethodInfo buildUp = GetMethodInfo<IBuilderStrategy>("BuildUp",
                                                                 typeof (IBuilderContext), typeof (Type), typeof (object),
                                                                 typeof (string));

            PropertyInfo prop =
                attr.ProviderHostType.GetProperty(attr.ProviderGetterProperty, BindingFlags.Static | BindingFlags.Public);
            if (prop == null)
            {
                throw new ArgumentException();
            }

            MethodInfo propInvoker = prop.GetGetMethod();
            if (propInvoker == null)
            {
                throw new ArgumentException();
            }
            Guid.NewGuid();
            MethodInfo newGuidMethod = typeof (Guid).GetMethod("NewGuid");
            MethodInfo guidToStringMethod = typeof (Guid).GetMethod("ToString", new Type[] {});
            if ((newGuidMethod == null) || (guidToStringMethod == null))
            {
                throw new ArgumentException();
            }

            //object value (declaration)
            LocalBuilder valueIndex = il.DeclareLocal(typeof (object));

            //object value = prop.GetGetMethod().Invoke(attr.ProviderHostType, null);
            //value = propInvoker.Invoke(null) (return value remains in the stack)
            il.EmitCall(OpCodes.Call, propInvoker, null);
            il.Emit(OpCodes.Stloc, valueIndex);

            //string id = Guid.NewGuid().ToString();
            //il.Emit(OpCodes.Ldtoken, typeof(Guid));
            //il.EmitCall(OpCodes.Call, newGuidMethod, null);
            //il.EmitCall(OpCodes.Call, guidToStringMethod, null);
            //il.Emit(OpCodes.Stloc, idIndex);

            // Get the head of the context chain
            il.Emit(OpCodes.Ldarg_0); // Get context onto the stack
            il.EmitCall(OpCodes.Callvirt, getHeadOfChain, null); // Now head of chain is on the stack

            // Build up parameters to the BuildUp call - context, type, existing, id
            il.Emit(OpCodes.Ldarg_0); // Push context onto stack
            EmitLoadType(il, parameterType);

            // Existing object is value
            il.Emit(OpCodes.Ldloc, valueIndex);

            // And the id
            //il.Emit(OpCodes.Ldloc,idIndex);
            il.Emit(OpCodes.Ldarg_3);

            // Call buildup on head of the chain
            il.EmitCall(OpCodes.Callvirt, buildUp, null);
        }

        /// <summary>
        /// Implements code for end invocations.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="interfaceType"></param>
        /// <param name="generator"></param>
        /// <param name="interfaceMethod"></param>
        protected override void OnInvokeEnd(TypeBuilder type, Type interfaceType, ILGenerator generator, MethodInfo interfaceMethod)
        {
            var skip = interfaceMethod.GetCustomAttributes(typeof(SkipProbeAttribute), false).OfType<SkipProbeAttribute>().FirstOrDefault();
            if ( skip != null && (skip.SkipActions & ProbeActions.End) == ProbeActions.End)
                return;

            var probeType = typeof(IMethodCallProbe<>).MakeGenericType(interfaceType);
            var endInvoke = probeType.GetMethod("OnEndInvoke");
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Ldfld, probeField());
            generator.Emit(OpCodes.Ldtoken, interfaceMethod);
            generator.EmitCall(OpCodes.Call, typeof(MethodBase).GetMethod("GetMethodFromHandle", BindingFlags.Public | BindingFlags.Static, null, new[] { typeof(RuntimeMethodHandle) }, null), null);
            generator.Emit(OpCodes.Ldarg_0);
            generator.EmitCall(OpCodes.Callvirt, endInvoke, null);

            base.OnInvokeEnd(type, interfaceType, generator, interfaceMethod);
        }

 public void EmitIL(ILGenerator body, FieldInfo tape, FieldInfo ptr)
 {
     body.Emit(OpCodes.Ldsfld, tape);
     body.Emit(OpCodes.Ldsfld, ptr);
     body.EmitCall(OpCodes.Call,
         typeof(Console).GetMethod("Read", new Type[0]), null);
     body.Emit(OpCodes.Stelem_I4);
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="il"></param>
        /// <param name="paramAttr"></param>
        /// <param name="parameterType"></param>
        public override void EmitParameterResolution(ILGenerator il, ParameterAttribute paramAttr, Type parameterType)
        {
            ServiceDependencyAttribute attr = (ServiceDependencyAttribute) paramAttr;
            MethodInfo getLocator = GetPropertyGetter<IBuilderContext>("Locator", typeof (IReadWriteLocator));
            MethodInfo getFromLocator = ObtainGetFromLocatorMethod();
            MethodInfo getServices =
                GetPropertyGetter<CompositionContainer>("Services", typeof (IServiceCollection));
            MethodInfo getFromServices = GetMethodInfo<IServiceCollection>("Get", typeof (Type), typeof (bool));
            ConstructorInfo newDependencyKey =
                GetConstructor<DependencyResolutionLocatorKey>(typeof (Type), typeof (string));

            // context.get_Locator
            il.Emit(OpCodes.Ldarg_0);
            il.EmitCall(OpCodes.Callvirt, getLocator, null);

            // new DependencyResolutionContainer(typeof(CompositionContainer), null)
            EmitLoadType(il, typeof (CompositionContainer));
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Newobj, newDependencyKey);
            // locator.Get(key)
            il.EmitCall(OpCodes.Callvirt, getFromLocator, null);
            il.Emit(OpCodes.Castclass, typeof (CompositionContainer));

            // container.get_Services
            il.EmitCall(OpCodes.Callvirt, getServices, null);

            if (attr.Type != null)
            {
                EmitLoadType(il, attr.Type);
            }
            else
            {
                EmitLoadType(il, parameterType);
            }

            if (attr.Required)
            {
                il.Emit(OpCodes.Ldc_I4_1);
            }
            else
            {
                il.Emit(OpCodes.Ldc_I4_0);
            }
            il.EmitCall(OpCodes.Callvirt, getFromServices, null);
        }

 public void EmitIL(ILGenerator body, FieldInfo tape, FieldInfo ptr)
 {
     body.Emit(OpCodes.Ldsfld, tape);
     body.Emit(OpCodes.Ldsfld, ptr);
     body.Emit(OpCodes.Ldelem_I4);
     body.Emit(OpCodes.Conv_U2);
     body.EmitCall(OpCodes.Call,
         typeof(Console).GetMethod("Write", new Type[] { typeof(char) }), null);
 }

 public void PushValue(ILGenerator il)
 {
     System.Type[] types = { typeof(string), typeof(openABAP.Runtime.IfValue) };
     MethodInfo mi = typeof(openABAP.Runtime.IfValue).GetMethod("Calculate", types);
     this.LeftChild.PushValue(il);
     il.Emit(OpCodes.Ldstr, this.Operator);
     this.RightChild.PushValue(il);
     il.EmitCall(OpCodes.Callvirt, mi, null);
 }

 public override void BuildAssembly( ILGenerator il )
 {
     System.Type[] types = {typeof(openABAP.Runtime.IfValue)};
     System.Type t = this.Target.GetRuntimeType();
     MethodInfo mi = t.GetMethod("Set", types);
     this.Target.PushValue( il );
     this.Expression.PushValue( il );
     il.EmitCall (OpCodes.Callvirt, mi, null);
 }

 /// <summary>
 /// 写入类型转换的 IL 指令。
 /// </summary>
 /// <param name="generator">IL 的指令生成器。</param>
 /// <param name="inputType">要转换的对象的类型。</param>
 /// <param name="outputType">要将输入对象转换到的类型。</param>
 /// <param name="isChecked">是否执行溢出检查。</param>
 public override void Emit(ILGenerator generator, Type inputType, Type outputType, bool isChecked)
 {
     Contract.Assume(inputType.IsNullable());
     Type inputUnderlyingType = Nullable.GetUnderlyingType(inputType);
     generator.EmitCall(inputType.GetMethod("get_Value"));
     if (inputUnderlyingType != outputType)
     {
         Conversion conversion = ConversionFactory.GetConversion(inputUnderlyingType, outputType);
         Contract.Assume(conversion != null);
         conversion.Emit(generator, inputUnderlyingType, outputType, isChecked);
     }
 }

        public static void Call(ILGenerator gen, MethodInfo method)
        {
            if (gen == null)
            {
                throw new ArgumentNullException("gen");
            }

            if (method == null)
            {
                throw new ArgumentNullException("method");
            }

            if (method.IsFinal || !method.IsVirtual)
            {
                gen.EmitCall(OpCodes.Call, method, null);
            }
            else
            {
                gen.EmitCall(OpCodes.Callvirt, method, null);
            }
        }