private void EmitReadBuiltInType(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var gen = Method.GetILGenerator(); EmitReadValue(gen, _context.TypeDescription, methodStorage); gen.Emit(OpCodes.Ret); }
private void EmitReadFields(ILGenerator gen, LocalBuilder local, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { foreach (var fieldDescription in _context.TypeDescription.Fields) { try { EmitBeginReadField(gen, fieldDescription); if (_context.TypeDescription.IsValueType) { gen.Emit(OpCodes.Ldloca_S, local); } else { gen.Emit(OpCodes.Ldloc, local); } EmitReadValue(gen, fieldDescription.FieldType, methodStorage); gen.Emit(OpCodes.Stfld, fieldDescription.Field); EmitEndReadField(gen, fieldDescription); } catch (SerializationException) { throw; } }
/// <inheritdoc /> public override void Compile(AbstractMethodsCompiler methods, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var serializationType = _context.TypeDescription.SerializationType; switch (serializationType) { case SerializationType.ByValue: if (_context.TypeDescription.IsBuiltIn) { EmitReadBuiltInType(methodStorage); } else { EmitReadByValue(methodStorage); } break; case SerializationType.ByReference: EmitReadByReference(); break; case SerializationType.Singleton: EmitReadSingleton(); break; case SerializationType.NotSerializable: throw new NotImplementedException(); case SerializationType.Unknown: throw new NotImplementedException(); default: throw new InvalidEnumArgumentException("", (int)serializationType, typeof(SerializationType)); } }
/// <inheritdoc /> public override void Compile(AbstractMethodsCompiler methods, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var requiresBoxing = _context.Type.IsPrimitive || _context.Type.IsValueType; var gen = _method.GetILGenerator(); //var hasValue = gen.DefineLabel(); //var end = gen.DefineLabel(); // //// If value != null: goto hasValue //EmitReadIsNull(gen); //gen.Emit(OpCodes.Ldc_I4_0); //gen.Emit(OpCodes.Ceq); //gen.Emit(OpCodes.Brfalse, hasValue); // //// return null //gen.Emit(OpCodes.Ldnull); //gen.Emit(OpCodes.Br_S, end); // :hasValue // return ReadValueNotNull(reader, serializer, remoteEndPoint); //gen.MarkLabel(hasValue); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Ldarg_2); gen.Emit(OpCodes.Call, methods.ReadValueMethod); if (requiresBoxing) { gen.Emit(OpCodes.Box, _context.Type); } //gen.MarkLabel(end); gen.Emit(OpCodes.Ret); }
private void EmitWriteFields(ILGenerator gen, Action loadValue, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { foreach (var field in _context.TypeDescription.Fields) { try { EmitBeginWriteField(gen, field); EmitWriteValue(gen, field.TypeDescription, () => { loadValue(); gen.Emit(OpCodes.Ldfld, field.Field); }, () => { loadValue(); gen.Emit(OpCodes.Ldflda, field.Field); }, methodStorage); EmitEndWriteField(gen, field); } catch (SerializationException) { throw; } }
private void EmitWriteByValue(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var gen = Method.GetILGenerator(); // The very first thing we want to do is to call the PreDeserializationCallback, if available. EmitCallBeforeSerialization(gen); Action loadValue = () => { if (_context.TypeDescription.IsValueType) { gen.Emit(OpCodes.Ldarga_S, arg: 1); } else { gen.Emit(OpCodes.Ldarg_1); } }; //Followed by the list of serializable fields EmitWriteFields(gen, loadValue, methodStorage); // Then the serializable properties EmitWriteProperties(gen, loadValue, methodStorage); // And finally call the PostDeserializationCallback, if available. EmitCallAfterSerialization(gen); gen.Emit(OpCodes.Ret); }
/// <summary> /// /// </summary> /// <param name="methodStorage"></param> private void EmitWriteBuiltInType(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var gen = Method.GetILGenerator(); var type = _context.TypeDescription; Action loadMember = () => { gen.Emit(OpCodes.Ldarg_1); }; Action loadMemberAddress = () => { if (type.IsValueType) { gen.Emit(OpCodes.Ldarga_S, 1); } else { gen.Emit(OpCodes.Ldarg_1); } }; EmitWriteValue(gen, type, loadMember, loadMemberAddress, methodStorage); gen.Emit(OpCodes.Ret); }
/// <summary> /// Emits il-code for all methods. /// </summary> protected void Compile(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { foreach (var compiler in _compilers) { compiler.Compile(this, methodStorage); } _typeBuilder.CreateType(); }
private void EmitReadByValue(ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage) { var gen = Method.GetILGenerator(); var tmp = gen.DeclareLocal(_context.Type); if (_context.Type.IsValueType) { gen.Emit(OpCodes.Ldloca, tmp); gen.Emit(OpCodes.Initobj, _context.Type); } else { var ctor = _context.Type.GetConstructor(new Type[0]); if (ctor == null) { throw new ArgumentException(string.Format("Type '{0}' is missing a parameterless constructor", _context.Type)); } gen.Emit(OpCodes.Newobj, ctor); gen.Emit(OpCodes.Stloc, tmp); } EmitBeginRead(gen); // tmp.BeforeDeserializationCallback(); EmitCallBeforeDeserialization(gen, tmp); EmitReadFields(gen, tmp, methodStorage); EmitReadProperties(gen, tmp, methodStorage); // tmp.AfterDeserializationCallback(); EmitCallAfterSerialization(gen, tmp); EmitEndRead(gen); // return tmp gen.Emit(OpCodes.Ldloc, tmp); gen.Emit(OpCodes.Ret); }
public void Compile(XmlMethodsCompiler methods, ISerializationMethodStorage <XmlMethodsCompiler> storage) { methods.Compile(storage); }
/// <inheritdoc /> public abstract void Compile(AbstractMethodsCompiler methods, ISerializationMethodStorage <AbstractMethodsCompiler> methodStorage);