Esempio n. 1
0
        private static void EmitParameters(ILGenerator ilGen, Type[] parameterTypes)
        {
            //Take the parameters passed as arguments and convert them to an array of RpcMessage.Parameters.
            if (parameterTypes.Length > 0)
            {
                ilGen.Emit(OpCodes.Ldc_I4, parameterTypes.Length);
                ilGen.Emit(OpCodes.Newarr, typeof(RpcMessage.Parameter));
                for (int i = 0; i < parameterTypes.Length; ++i)
                {
                    ilGen.Emit(OpCodes.Dup);                 //for array store
                    ilGen.Emit(OpCodes.Ldc_I4, i);           //index for array store

                    ilGen.Emit(OpCodes.Ldarg, (short)i + 1); //argument for ParameterConverter function

                    ThunkHelpers.EmitParameterToMessage(ilGen, parameterTypes[i]);

                    ilGen.Emit(OpCodes.Stelem_Ref); //array store result from ParameterConverter
                }
            }
            else
            {
                ilGen.Emit(OpCodes.Ldnull);
            }
        }
Esempio n. 2
0
        public static Delegate BuildThunk(RpcMethodDescriptor method)
        {
            var dynMethod = new DynamicMethod("ServiceThunk", typeof(void),
                                              new[] { typeof(object), typeof(IList <RpcMessage.Parameter>), typeof(RpcMessage.Result) },
                                              typeof(ServiceThunkBuilder).Module);

            ILGenerator ilGen = dynMethod.GetILGenerator();

            //verify number of parameters
            ilGen.Emit(OpCodes.Ldarg_1);                              //push IList<RpcMessage.Parameter>
            ilGen.Emit(OpCodes.Ldc_I4, method.ParameterTypes.Length); //push number of expected parameters
            ilGen.Emit(OpCodes.Ldarg_2);                              //push RpcMessage.Result
            ilGen.Emit(OpCodes.Call, typeof(ServiceThunkHelpers).GetMethod("VerifyParameterCount"));
            Label paramVerifyLabel = ilGen.DefineLabel();

            ilGen.Emit(OpCodes.Brtrue, paramVerifyLabel);
            ilGen.Emit(OpCodes.Ret);
            ilGen.MarkLabel(paramVerifyLabel);

            //load the RpcMessage.Result to the stack, for the call to set the result
            if (method.ReturnType != typeof(void))
            {
                ilGen.Emit(OpCodes.Ldarg_2);
            }
            //load the service instance to the stack, for the call to the service instance
            ilGen.Emit(OpCodes.Ldarg_0);

            //load the service call parameters to the stack, if they are the wrong type then an error is stored
            //in the result message and we return early
            MethodInfo paramIndexer = typeof(IList <RpcMessage.Parameter>).GetProperty("Item").GetGetMethod();

            for (int i = 0; i < method.ParameterTypes.Length; ++i)
            {
                Type paramType = method.ParameterTypes[i];

                //get RpcMessage.Parameter by calling IList indexer
                ilGen.Emit(OpCodes.Ldarg_1);
                ilGen.Emit(OpCodes.Ldc_I4, i);
                ilGen.Emit(OpCodes.Callvirt, paramIndexer);

                ilGen.Emit(OpCodes.Ldarg_2);                              //push RpcMessage.Result
                LocalBuilder paramLocal = ilGen.DeclareLocal(paramType);
                ilGen.Emit(OpCodes.Ldloca, (short)paramLocal.LocalIndex); //push ref to result local
                EmitParameter(ilGen, paramType);

                Label continueLabel = ilGen.DefineLabel();
                ilGen.Emit(OpCodes.Brtrue, continueLabel); //success, continue with next parameter

                //failed, stack cleanup
                for (int j = 0; j < i; ++j)
                {
                    ilGen.Emit(OpCodes.Pop); //pop previous parameters
                }
                ilGen.Emit(OpCodes.Pop);     //pop service instance
                if (method.ReturnType != typeof(void))
                {
                    ilGen.Emit(OpCodes.Pop); //pop RpcMessage.Result
                }
                ilGen.Emit(OpCodes.Ret);

                ilGen.MarkLabel(continueLabel);

                //now push the actual parameter ready for the actual call
                ilGen.Emit(OpCodes.Ldloc, paramLocal.LocalIndex);
            }

            //now call the actual service instance method
            ilGen.Emit(OpCodes.Callvirt, method.SyncCallMethod);

            //get the return value, storing it in the result message. We know the type, no need for any error
            //checking
            if (method.ReturnType != typeof(void))
            {
                //check if result is null
                ilGen.Emit(OpCodes.Ldarg_2);
                ilGen.Emit(OpCodes.Ldnull);
                Label nullReturnLabel = ilGen.DefineLabel();
                ilGen.Emit(OpCodes.Beq, nullReturnLabel);

                //convert return value to a message and store it in the result message
                ThunkHelpers.EmitParameterToMessage(ilGen, method.ReturnType);
                ilGen.Emit(OpCodes.Call, typeof(RpcMessage.Result).GetProperty("CallResult").GetSetMethod());
                ilGen.Emit(OpCodes.Ret);

                ilGen.MarkLabel(nullReturnLabel);
                ilGen.Emit(OpCodes.Pop); //pop return value
                ilGen.Emit(OpCodes.Pop); //pop result message
            }

            ilGen.Emit(OpCodes.Ret);

            return(dynMethod.CreateDelegate(typeof(RpcServer.MethodDelegate)));
        }