AddMethodImpl()

MethodBuilder System.Reflection.DispatchProxyGenerator.ProxyBuilder.AddMethodImpl ( MethodInfo mi, int methodInfoIndex )

inlineprivate

Definition at line 425 of file DispatchProxyGenerator.cs.

        {
            ParameterInfo[] parameters = mi.GetParameters();
            Type[] array = new Type[parameters.Length];
            Type[][] array2 = new Type[array.Length][];
            for (int i = 0; i < parameters.Length; i++)
            {
                array[i] = parameters[i].ParameterType;
                array2[i] = parameters[i].GetRequiredCustomModifiers();
            }
            MethodBuilder methodBuilder = _tb.DefineMethod(mi.Name, MethodAttributes.Public | MethodAttributes.Virtual, CallingConventions.Standard, mi.ReturnType, null, null, array, array2, null);
            if (mi.ContainsGenericParameters)
            {
                Type[] genericArguments = mi.GetGenericArguments();
                string[] array3 = new string[genericArguments.Length];
                for (int j = 0; j < genericArguments.Length; j++)
                {
                    array3[j] = genericArguments[j].Name;
                }
                GenericTypeParameterBuilder[] array4 = methodBuilder.DefineGenericParameters(array3);
                for (int k = 0; k < array4.Length; k++)
                {
                    array4[k].SetGenericParameterAttributes(genericArguments[k].GenericParameterAttributes);
                }
            }
            ILGenerator iLGenerator = methodBuilder.GetILGenerator();
            ParametersArray parametersArray = new ParametersArray(iLGenerator, array);
            iLGenerator.Emit(OpCodes.Nop);
            GenericArray<object> genericArray = new GenericArray<object>(iLGenerator, parameters.Length);
            for (int l = 0; l < parameters.Length; l++)
            {
                if (!parameters[l].IsOut || !parameters[l].ParameterType.IsByRef || parameters[l].IsIn)
                {
                    genericArray.BeginSet(l);
                    parametersArray.Get(l);
                    genericArray.EndSet(parameters[l].ParameterType);
                }
            }
            LocalBuilder local = iLGenerator.DeclareLocal(typeof(MethodInfo));
            iLGenerator.Emit(OpCodes.Ldarg_0);
            iLGenerator.Emit(OpCodes.Ldfld, _fields[0]);
            iLGenerator.Emit(OpCodes.Ldc_I4, methodInfoIndex);
            iLGenerator.Emit(OpCodes.Ldelem_Ref);
            iLGenerator.Emit(OpCodes.Stloc, local);
            if (mi.ContainsGenericParameters)
            {
                iLGenerator.Emit(OpCodes.Ldloc, local);
                Type[] genericArguments2 = mi.GetGenericArguments();
                GenericArray<Type> genericArray2 = new GenericArray<Type>(iLGenerator, genericArguments2.Length);
                for (int m = 0; m < genericArguments2.Length; m++)
                {
                    genericArray2.BeginSet(m);
                    iLGenerator.Emit(OpCodes.Ldtoken, genericArguments2[m]);
                    iLGenerator.Emit(OpCodes.Call, s_getTypeFromHandleMethod);
                    genericArray2.EndSet(typeof(Type));
                }
                genericArray2.Load();
                iLGenerator.Emit(OpCodes.Callvirt, s_makeGenericMethodMethod);
                iLGenerator.Emit(OpCodes.Stloc, local);
            }
            LocalBuilder localBuilder = ((mi.ReturnType != typeof(void)) ? iLGenerator.DeclareLocal(typeof(object)) : null);
            iLGenerator.Emit(OpCodes.Ldarg_0);
            iLGenerator.Emit(OpCodes.Ldloc, local);
            genericArray.Load();
            iLGenerator.Emit(OpCodes.Callvirt, s_dispatchProxyInvokeMethod);
            if (localBuilder != null)
            {
                iLGenerator.Emit(OpCodes.Stloc, localBuilder);
            }
            else
            {
                iLGenerator.Emit(OpCodes.Pop);
            }
            for (int n = 0; n < parameters.Length; n++)
            {
                if (parameters[n].ParameterType.IsByRef)
                {
                    parametersArray.BeginSet(n);
                    genericArray.Get(n);
                    parametersArray.EndSet(n, typeof(object));
                }
            }
            if (localBuilder != null)
            {
                iLGenerator.Emit(OpCodes.Ldloc, localBuilder);
                Convert(iLGenerator, typeof(object), mi.ReturnType, isAddress: false);
            }
            iLGenerator.Emit(OpCodes.Ret);
            _tb.DefineMethodOverride(methodBuilder, mi);
            return methodBuilder;
        }

References System.Reflection.DispatchProxyGenerator.ProxyBuilder._fields, System.Reflection.DispatchProxyGenerator.ProxyBuilder._tb, System.array, System.Reflection.Emit.OpCodes.Call, System.Reflection.Emit.OpCodes.Callvirt, System.Reflection.DispatchProxyGenerator.ProxyBuilder.Convert(), System.Reflection.Emit.TypeBuilder.DefineMethod(), System.Reflection.Emit.TypeBuilder.DefineMethodOverride(), System.Reflection.ParameterInfo.GetRequiredCustomModifiers(), System.Reflection.ParameterInfo.IsIn, System.Reflection.Emit.OpCodes.Ldarg_0, System.Reflection.Emit.OpCodes.Ldc_I4, System.Reflection.Emit.OpCodes.Ldelem_Ref, System.Reflection.Emit.OpCodes.Ldfld, System.Reflection.Emit.OpCodes.Ldloc, System.Reflection.Emit.OpCodes.Ldtoken, System.Reflection.Emit.OpCodes.Nop, System.Reflection.ParameterInfo.ParameterType, System.Reflection.Emit.OpCodes.Pop, System.Reflection.Emit.OpCodes.Ret, System.Reflection.DispatchProxyGenerator.s_dispatchProxyInvokeMethod, System.Reflection.DispatchProxyGenerator.s_getTypeFromHandleMethod, System.Reflection.DispatchProxyGenerator.s_makeGenericMethodMethod, and System.Reflection.Emit.OpCodes.Stloc.

Referenced by System.Reflection.DispatchProxyGenerator.ProxyBuilder.AddInterfaceImpl().