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);
}
