protected override void EmitLoadMember(MyILGenerator il, Action <MyILGenerator> emitLoad, FieldInfo member) { emitLoad(il); il.Ldfld(member); }
protected override void EmitLoadAsString(MyILGenerator il, Action <MyILGenerator> emitLoad) { emitLoad(il); il.Callvirt(GetAssemblyQualifiedNameMethod); }
protected override void EmitParseFromString(MyILGenerator il) { il.Call(GetTypeMethod); }
protected override void EmitLoadAsString(MyILGenerator il, Action <MyILGenerator> emitLoad) { emitLoad(il); }
protected override void EmitParseFromString(MyILGenerator il) { }
protected abstract void EmitLoadAsString(MyILGenerator il, Action <MyILGenerator> emitLoad);
protected abstract void EmitParseFromString(MyILGenerator il);
public ProxyMethodEmittingContext(MyILGenerator il, ProxyClassFieldCache fieldCache) : base(il) { this.fieldCache = fieldCache; }
protected abstract void EmitLoadCount(MyILGenerator il, Action <MyILGenerator> emitLoad);
protected abstract void EmitCreateCollection(MyILGenerator il, LocalBuilder lengthVar);
private void CreateMethod(ProxyClassBuildingContext classContext, string path, MethodDescription methodDesc) { var methodBuilder = classContext.Builder.DefineMethod(methodDesc.Name, MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual); var genericTypeParameterBuilders = methodDesc.GenericParameters.Any() ? methodBuilder.DefineGenericParameters(methodDesc.GenericParameters.Select(x => x.Name).ToArray()) : new GenericTypeParameterBuilder[0]; var genericTypeParameterCodecs = genericTypeParameterBuilders.Select(x => new ProxyMethodGenericArgumentCodec(x)).ToArray(); var genericArgumentMap = genericTypeParameterBuilders.ToDictionary(x => x.Name, x => (Type)x); var parameterDescriptions = methodDesc.Parameters.Select(x => x.DeepSubstituteGenerics(genericArgumentMap)).ToArray(); var parameterTypesAdjustedForRefs = parameterDescriptions.Select(x => x.Way == MethodParameterWay.Val ? x.Type : x.Type.MakeByRefType()).ToArray(); var allParameterCodecs = parameterDescriptions.Select(x => new ProxyMethodParameterCodec(x)).ToArray(); var retvalType = methodDesc.ReturnType.DeepSubstituteGenerics(genericArgumentMap); methodBuilder.SetParameters(parameterTypesAdjustedForRefs); methodBuilder.SetReturnType(retvalType); methodBuilder.SetImplementationFlags(MethodImplAttributes.Managed); var il = new MyILGenerator(methodBuilder.GetILGenerator()); var emittingContext = new ProxyMethodEmittingContext(il, classContext.Fields); var requestDataArrayVar = il.DeclareLocal(typeof(byte[])); // byte[] dataArray var requestParametersCodecs = allParameterCodecs.Where(x => x.IsRequestParameter).ToArray(); if (requestParametersCodecs.Any() || genericTypeParameterBuilders.Any()) { bool haveSizeOnStack = false; foreach (var codec in genericTypeParameterCodecs) { codec.EmitCalculateSize(emittingContext); // stack_0 += CalculateSize(T_i) EmitAddIf(il, ref haveSizeOnStack); } foreach (var parameter in requestParametersCodecs) { parameter.EmitCalculateSize(emittingContext); // stack_0 += CalculateSize(arg_i) EmitAddIf(il, ref haveSizeOnStack); } il.Newarr(typeof(byte)); // dataArray = new byte[stack_0] il.Stloc(requestDataArrayVar); var pinnedVar = il.PinArray(typeof(byte), requestDataArrayVar); // var pinned dataPointer = pin(dataArray) il.Ldloc(pinnedVar); // data = dataPointer il.Stloc(emittingContext.DataPointerVar); foreach (var codec in genericTypeParameterCodecs) { codec.EmitEncode(emittingContext); // Encode(T_i, data) } foreach (var codec in requestParametersCodecs) { codec.EmitEncode(emittingContext); // Encode(arg_i, data) } } else { il.Ldnull(); // dataArray = null il.Stloc(requestDataArrayVar); } il.Ldarg(0); // stack_0 = methodCallProcessor il.Ldfld(classContext.Fields.Processor); il.Ldtoken(classContext.InterfaceType); // stack_1 = typeof(T) il.Call(TypeMethods.GetTypeFromHandle); il.Ldstr(string.Format("{0}/{1}", path, methodDesc.Name)); // stack_2 = SuperServicePath/ServiceName/MethodName il.Ldarg(0); // stack_3 = scope il.Ldfld(classContext.Fields.Scope); il.Ldloc(requestDataArrayVar); // stack_4 = dataArray il.Ldarg(0); // stack_5 = timeoutSettings il.Ldfld(classContext.Fields.TimeoutSettings); var responseParameterCodecs = allParameterCodecs.Where(x => x.IsResponseParameter).ToArray(); if (responseParameterCodecs.Any() && methodDesc.RemotingType != MethodRemotingType.Direct) { throw new ArgumentException(string.Format("Error processing {0} method: only direct methods can have Ref or Out parameters", path)); } switch (methodDesc.RemotingType) { case MethodRemotingType.Direct: EmitProcessDirect(emittingContext, responseParameterCodecs, retvalType); break; case MethodRemotingType.AsyncVoid: EmitProcessAsyncVoid(il); break; case MethodRemotingType.AsyncWithRetval: EmitProcessAsyncWithRetval(classContext, emittingContext, methodDesc.Name, genericTypeParameterBuilders, retvalType); break; default: throw new ArgumentOutOfRangeException(); } il.Ret(); }
private static void EmitProcessAsyncVoid(MyILGenerator il) { il.Callvirt(OutgoingRequestProcessorMethods.ProcessAsync); // stack_0 = stack_0.ProcessAsync(stack_1, stack_2, stack_3, stack_4, stack_5) }