public ProxyCompiler(ISerializerCompiler serializer, ModuleBuilder module, string proxyTypeName, Type interfaceType) : base(serializer, interfaceType) { if (module == null) { throw new ArgumentNullException(nameof(module)); } if (proxyTypeName == null) { throw new ArgumentNullException(nameof(proxyTypeName)); } _module = module; _typeBuilder = _module.DefineType(proxyTypeName, TypeAttributes.Class, typeof(object), new[] { interfaceType }); _typeBuilder.AddInterfaceImplementation(typeof(IProxy)); _perEventSchedulers = new Dictionary <EventInfo, FieldBuilder>(); ObjectId = _typeBuilder.DefineField("_objectId", typeof(ulong), FieldAttributes.Private | FieldAttributes.InitOnly); EndPoint = _typeBuilder.DefineField("_endPoint", typeof(IRemotingEndPoint), FieldAttributes.Private | FieldAttributes.InitOnly); Channel = _typeBuilder.DefineField("_channel", typeof(IEndPointChannel), FieldAttributes.Private | FieldAttributes.InitOnly); Serializer = _typeBuilder.DefineField("_serializer", typeof(ISerializer), FieldAttributes.Private | FieldAttributes.InitOnly); _fields = new Dictionary <string, FieldBuilder>(); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { loadWriter(); loadValue(); gen.Emit(OpCodes.Call, _getMajor); gen.Emit(OpCodes.Call, Methods.WriteInt32); loadWriter(); loadValue(); gen.Emit(OpCodes.Call, _getMinor); gen.Emit(OpCodes.Call, Methods.WriteInt32); loadWriter(); loadValue(); gen.Emit(OpCodes.Call, _getBuild); gen.Emit(OpCodes.Call, Methods.WriteInt32); loadWriter(); loadValue(); gen.Emit(OpCodes.Call, _getRevision); gen.Emit(OpCodes.Call, Methods.WriteInt32); }
public abstract void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true);
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitWriteNullableValue( gen, loadWriter, loadValue, () => { var data = gen.DeclareLocal(typeof(byte[])); loadValue(); gen.Emit(OpCodes.Call, _ipAddressGetAddressBytes); gen.Emit(OpCodes.Stloc, data); loadWriter(); gen.Emit(OpCodes.Ldloc, data); gen.Emit(OpCodes.Call, Methods.ArrayGetLength); gen.Emit(OpCodes.Call, Methods.WriteInt32); loadWriter(); gen.Emit(OpCodes.Ldloc, data); gen.Emit(OpCodes.Call, Methods.WriteBytes); }, valueCanBeNull); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { LocalBuilder dateTime = null; serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValueAddress(); gen.Emit(OpCodes.Call, _getDateTime); }, () => { if (dateTime == null) { loadValueAddress(); dateTime = gen.DeclareLocal(typeof(DateTime)); gen.Emit(OpCodes.Call, _getDateTime); gen.Emit(OpCodes.Stloc, dateTime); } gen.Emit(OpCodes.Ldloca, dateTime); }, loadSerializer, loadRemotingEndPoint, typeof(DateTime)); LocalBuilder offset = null; serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValueAddress(); gen.Emit(OpCodes.Call, _getOffset); }, () => { if (offset == null) { loadValueAddress(); offset = gen.DeclareLocal(typeof(TimeSpan)); gen.Emit(OpCodes.Call, _getOffset); gen.Emit(OpCodes.Stloc, offset); } gen.Emit(OpCodes.Ldloca, offset); }, loadSerializer, loadRemotingEndPoint, typeof(TimeSpan)); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitReadNullableValue(gen, loadReader, () => { IPAddressSerializer.EmitReadValue(gen, serializerCompiler, loadReader, loadSerializer, loadRemotingEndPoint, type, valueCanBeNull: false); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Newobj, Ctor); }, valueCanBeNull); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { var keyType = type.GenericTypeArguments[0]; var valueType = type.GenericTypeArguments[1]; var ctor = type.GetConstructor(new[] { keyType, valueType }); serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadRemotingEndPoint, keyType); serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadRemotingEndPoint, valueType); gen.Emit(OpCodes.Newobj, ctor); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitWriteNullableValue(gen, loadWriter, loadValue, () => { var addr = gen.DeclareLocal(typeof(IPAddress)); loadValue(); gen.Emit(OpCodes.Callvirt, GetAddress); gen.Emit(OpCodes.Stloc, addr); IPAddressSerializer.EmitWriteValue(gen, serializerCompiler, loadWriter, () => gen.Emit(OpCodes.Ldloc, addr), loadValueAddress, loadSerializer, loadRemotingEndPoint, type, valueCanBeNull: false); loadWriter(); loadValue(); gen.Emit(OpCodes.Callvirt, GetPort); gen.Emit(OpCodes.Call, Methods.WriteInt32); }, valueCanBeNull); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { loadReader(); gen.Emit(OpCodes.Call, Methods.ReadDecimal); }
protected Compiler(ISerializerCompiler serializer, Type interfaceType) { if (interfaceType == null) { throw new ArgumentNullException(nameof(interfaceType)); } SerializerCompiler = serializer; InterfaceType = interfaceType; }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { var valueType = type.GenericTypeArguments[0]; var getHasValue = type.GetProperty("HasValue").GetMethod; var getValue = type.GetProperty("Value").GetMethod; var hasValue = gen.DeclareLocal(typeof(bool)); var end = gen.DefineLabel(); loadWriter(); loadValueAddress(); gen.Emit(OpCodes.Call, getHasValue); gen.Emit(OpCodes.Stloc, hasValue); gen.Emit(OpCodes.Ldloc, hasValue); gen.Emit(OpCodes.Call, Methods.WriteBool); gen.Emit(OpCodes.Ldloc, hasValue); gen.Emit(OpCodes.Brfalse, end); LocalBuilder value = null; serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValueAddress(); gen.Emit(OpCodes.Call, getValue); }, () => { if (value == null) { value = gen.DeclareLocal(valueType); loadValueAddress(); gen.Emit(OpCodes.Call, getValue); gen.Emit(OpCodes.Stloc, value); } gen.Emit(OpCodes.Ldloca, value); }, loadSerializer, loadRemotingEndPoint, valueType); gen.MarkLabel(end); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitWriteNullableValue(gen, loadWriter, loadValue, () => { var end = gen.DefineLabel(); // For now we only allow serialization of "special" // values, hence we always place 1 in the stream, however // in the future we could allow arbitrary Level values // to be serialized, requiring us to store the // (Level.Value, Level.Name, Level.DisplayName) tuple. // For that case, we would have to write 0 here. loadWriter(); gen.Emit(OpCodes.Ldc_I4_1); gen.Emit(OpCodes.Callvirt, Methods.WriteBool); for (int i = 0; i < HardcodedLevels.Count; ++i) { var next = gen.DefineLabel(); // if (ReferenceEquals(value, <fld>)) loadValue(); gen.Emit(OpCodes.Ldsfld, HardcodedLevels[i].Field); gen.Emit(OpCodes.Call, Methods.ObjectReferenceEquals); gen.Emit(OpCodes.Brfalse, next); // writer.WriteByte(<constant>) loadWriter(); gen.Emit(OpCodes.Ldc_I4, (int)HardcodedLevels[i].SerializedValue); gen.Emit(OpCodes.Callvirt, Methods.WriteByte); gen.Emit(OpCodes.Br, end); gen.MarkLabel(next); } gen.Emit(OpCodes.Newobj, Methods.NotImplementedCtor); gen.Emit(OpCodes.Throw); gen.MarkLabel(end); }, valueCanBeNull); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { loadWriter(); loadValueAddress(); gen.Emit(OpCodes.Call, _getTicks); gen.Emit(OpCodes.Call, Methods.WriteLong); }
public RemotingProxyCreator(ModuleBuilder module, ISerializerCompiler serializer) { if (module == null) { throw new ArgumentNullException(nameof(module)); } if (serializer == null) { throw new ArgumentNullException(nameof(serializer)); } _module = module; _serializer = serializer; _interfaceToProxy = new Dictionary <Type, Type>(); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadSerializer, typeof(string)); gen.Emit(OpCodes.Ldc_I4, (int)UriKind.RelativeOrAbsolute); gen.Emit(OpCodes.Newobj, _ctor); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { loadReader(); gen.Emit(OpCodes.Call, Methods.ReadLong); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadByte); gen.Emit(OpCodes.Conv_I4); gen.Emit(OpCodes.Newobj, _ctor); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitReadNullableValue(gen, loadReader, () => { var readSpecialValue = gen.DefineLabel(); // if (!reader.ReadBool()) loadReader(); gen.Emit(OpCodes.Callvirt, Methods.ReadBool); gen.Emit(OpCodes.Ldc_I4_1); gen.Emit(OpCodes.Ceq); gen.Emit(OpCodes.Brtrue_S, readSpecialValue); // throw new NotImplementedException gen.Emit(OpCodes.Newobj, Methods.NotImplementedCtor); gen.Emit(OpCodes.Throw); // else ... gen.MarkLabel(readSpecialValue); loadReader(); gen.Emit(OpCodes.Callvirt, Methods.ReadByte); var jumpTable = HardcodedLevels.Select(x => gen.DefineLabel()).ToArray(); var end = gen.DefineLabel(); gen.Emit(OpCodes.Switch, jumpTable); // Default case => we throw here - new serializer will implement it... gen.Emit(OpCodes.Newobj, Methods.NotImplementedCtor); gen.Emit(OpCodes.Throw); for (int i = 0; i < jumpTable.Length; ++i) { gen.MarkLabel(jumpTable[i]); gen.Emit(OpCodes.Ldsfld, HardcodedLevels[i].Field); gen.Emit(OpCodes.Br, end); } gen.MarkLabel(end); }, valueCanBeNull); }
public ArrayWithIntPrefixSerializer(Type serializer, object[] parameters = null) { if (serializer == null) { throw new ArgumentNullException(nameof(serializer)); } if (typeof(ISerializer).IsAssignableFrom(serializer)) { _serializer = (ISerializer)Activator.CreateInstance(serializer, parameters); } else if (typeof(ISerializerCompiler).IsAssignableFrom(serializer)) { _compiler = (ISerializerCompiler)Activator.CreateInstance(serializer, parameters); } else { throw new ArgumentException($"{serializer.FullName} must be a ISerializer or ISerializerCompiler", nameof(serializer)); } }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadRemotingEndPoint, typeof(DateTime)); serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadRemotingEndPoint, typeof(TimeSpan)); gen.Emit(OpCodes.Newobj, _ctor); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitReadNullableValue( gen, loadReader, () => { loadSerializer(); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadString); gen.Emit(OpCodes.Callvirt, Methods.SerializerGetType); }, valueCanBeNull ); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getOriginalString); }, null, loadSerializer, loadRemotingEndPoint, typeof(string)); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitWriteNullableValue( gen, loadWriter, loadValue, () => { loadWriter(); loadValue(); gen.Emit(OpCodes.Call, Methods.WriteString); }, valueCanBeNull); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { EmitReadNullableValue( gen, loadReader, () => { // new IPAddress(writer.ReadBytes(writer.ReadInt())); loadReader(); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Call, Methods.ReadBytes); gen.Emit(OpCodes.Newobj, _ipAddressFromBytes); }, valueCanBeNull ); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { var valueType = type.GenericTypeArguments[0]; var ctor = type.GetConstructor(new[] { valueType }); var end = gen.DefineLabel(); var noValue = gen.DefineLabel(); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadBool); gen.Emit(OpCodes.Brfalse, noValue); serializerCompiler.EmitReadValue(gen, loadReader, loadSerializer, loadRemotingEndPoint, valueType); gen.Emit(OpCodes.Newobj, ctor); gen.Emit(OpCodes.Br_S, end); gen.MarkLabel(noValue); var @null = gen.DeclareLocal(type); gen.Emit(OpCodes.Ldloca, @null); gen.Emit(OpCodes.Initobj, type); gen.Emit(OpCodes.Ldloc, @null); gen.MarkLabel(end); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getKey); }, null, loadSerializer, loadRemotingEndPoint, typeof(byte[])); serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getName); }, null, loadSerializer, loadRemotingEndPoint, typeof(string)); serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getVersion); }, null, loadSerializer, loadRemotingEndPoint, typeof(Version)); serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getProcessorArchitecture); }, null, loadSerializer, loadRemotingEndPoint, typeof(string)); serializerCompiler.EmitWriteValue(gen, loadWriter, () => { loadValue(); gen.Emit(OpCodes.Call, _getCulture); }, null, loadSerializer, loadRemotingEndPoint, typeof(string)); }
public override void EmitWriteValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadWriter, Action loadValue, Action loadValueAddress, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { var keyType = type.GenericTypeArguments[0]; var valueType = type.GenericTypeArguments[1]; var getKey = type.GetProperty("Key").GetMethod; var getValue = type.GetProperty("Value").GetMethod; Action loadKeyValue = () => { loadValueAddress(); gen.Emit(OpCodes.Call, getKey); }; LocalBuilder key = null; Action loadKeyValueAddress = () => { if (key == null) { key = gen.DeclareLocal(keyType); loadValue(); gen.Emit(OpCodes.Stloc, key); } gen.Emit(OpCodes.Ldloca, key); }; serializerCompiler.EmitWriteValue(gen, loadWriter, loadKeyValue, loadKeyValueAddress, loadSerializer, loadRemotingEndPoint, keyType ); Action loadValueValue = () => { loadValueAddress(); gen.Emit(OpCodes.Call, getValue); }; LocalBuilder value = null; Action loadValueValueAddress = () => { if (value == null) { value = gen.DeclareLocal(valueType); loadValueValue(); gen.Emit(OpCodes.Stloc, value); } gen.Emit(OpCodes.Ldloca, value); }; serializerCompiler.EmitWriteValue(gen, loadWriter, loadValueValue, loadValueValueAddress, loadSerializer, loadRemotingEndPoint, valueType); }
public override void EmitReadValue(ILGenerator gen, ISerializerCompiler serializerCompiler, Action loadReader, Action loadSerializer, Action loadRemotingEndPoint, Type type, bool valueCanBeNull = true) { var major = gen.DeclareLocal(typeof(int)); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Stloc, major); var minor = gen.DeclareLocal(typeof(int)); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Stloc, minor); var build = gen.DeclareLocal(typeof(int)); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Stloc, build); var revision = gen.DeclareLocal(typeof(int)); loadReader(); gen.Emit(OpCodes.Call, Methods.ReadInt32); gen.Emit(OpCodes.Stloc, revision); var end = gen.DefineLabel(); var majorMinor = gen.DefineLabel(); gen.Emit(OpCodes.Ldloc, build); gen.Emit(OpCodes.Ldc_I4_0); gen.Emit(OpCodes.Blt, majorMinor); var majorMinorBuild = gen.DefineLabel(); gen.Emit(OpCodes.Ldloc, revision); gen.Emit(OpCodes.Ldc_I4_0); gen.Emit(OpCodes.Blt, majorMinorBuild); var all = gen.DefineLabel(); gen.Emit(OpCodes.Br, all); // Thanks for not making this easy... gen.MarkLabel(majorMinor); gen.Emit(OpCodes.Ldloc, major); gen.Emit(OpCodes.Ldloc, minor); gen.Emit(OpCodes.Newobj, _ctorMajorMinor); gen.Emit(OpCodes.Br, end); gen.MarkLabel(majorMinorBuild); gen.Emit(OpCodes.Ldloc, major); gen.Emit(OpCodes.Ldloc, minor); gen.Emit(OpCodes.Ldloc, build); gen.Emit(OpCodes.Newobj, _ctorMajorMinorBuild); gen.Emit(OpCodes.Br, end); gen.MarkLabel(all); gen.Emit(OpCodes.Ldloc, major); gen.Emit(OpCodes.Ldloc, minor); gen.Emit(OpCodes.Ldloc, build); gen.Emit(OpCodes.Ldloc, revision); gen.Emit(OpCodes.Newobj, _ctorMajorMinorBuildRevision); gen.Emit(OpCodes.Br, end); gen.MarkLabel(end); }