// T Deserialize([arg:1]ref MessagePackReader reader, [arg:2]MessagePackSerializerOptions options);
static void BuildDeserialize(
Type type,
UnionCaseInfo[] infos,
MethodBuilder method,
FieldBuilder[] stringByteKeysFields,
ILGenerator il,
int firstArgIndex
)
{
var ti = type.GetTypeInfo();
var reader = new ArgumentField(il, firstArgIndex, @ref: true);
var argOptions = new ArgumentField(il, firstArgIndex + 1);
// if(MessagePackBinary.TryReadNil()) { return null; }
Label falseLabel = il.DefineLabel();
reader.EmitLdarg();
il.EmitCall(MessagePackReaderTypeInfo.TryReadNil);
il.Emit(OpCodes.Brfalse_S, falseLabel);
if (ti.IsClass)
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ret);
}
else
{
il.Emit(OpCodes.Ldstr, "typecode is null, struct not supported");
il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
il.Emit(OpCodes.Throw);
}
il.MarkLabel(falseLabel);
// IFormatterResolver resolver = options.Resolver;
LocalBuilder localResolver = il.DeclareLocal(typeof(IFormatterResolver));
argOptions.EmitLdarg();
il.EmitCall(getResolverFromOptions);
il.EmitStloc(localResolver);
// read-array header and validate, reader.ReadArrayHeader() != 2) throw;
Label rightLabel = il.DefineLabel();
reader.EmitLdarg();
il.EmitCall(MessagePackReaderTypeInfo.ReadArrayHeader);
il.EmitLdc_I4(2);
il.Emit(OpCodes.Beq_S, rightLabel);
il.Emit(OpCodes.Ldstr, "Invalid Union data was detected. Type:" + type.FullName);
il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
il.Emit(OpCodes.Throw);
il.MarkLabel(rightLabel);
// read key
LocalBuilder key = il.DeclareLocal(typeof(int));
reader.EmitLdarg();
il.EmitCall(MessagePackReaderTypeInfo.ReadInt32);
il.EmitStloc(key);
// switch->read
LocalBuilder result = il.DeclareLocal(type);
Label loopEnd = il.DefineLabel();
if (ti.IsClass)
{
il.Emit(OpCodes.Ldnull);
il.EmitStloc(result);
}
il.Emit(OpCodes.Ldloc, key);
var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Info = x }).ToArray();
il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());
// default
reader.EmitLdarg();
il.EmitCall(MessagePackReaderTypeInfo.Skip);
il.Emit(OpCodes.Br, loopEnd);
foreach (var item in switchLabels)
{
il.MarkLabel(item.Label);
EmitDeserializeUnionCase(
il,
type,
UnionSerializationInfo.CreateOrNull(type, item.Info),
key,
stringByteKeysFields[item.Info.Tag],
reader,
argOptions,
localResolver
);
il.Emit(OpCodes.Stloc, result);
il.Emit(OpCodes.Br, loopEnd);
}
il.MarkLabel(loopEnd);
il.Emit(OpCodes.Ldloc, result);
il.Emit(OpCodes.Ret);
}
// T Deserialize([arg:1]byte[] bytes, [arg:2]int offset, [arg:3]IFormatterResolver formatterResolver, [arg:4]out int readSize);
static void BuildDeserialize(Type type, Microsoft.FSharp.Reflection.UnionCaseInfo[] infos, MethodBuilder method, FieldBuilder[] stringByteKeysFields, ILGenerator il)
{
var ti = type.GetTypeInfo();
// if(MessagePackBinary.IsNil) readSize = 1, return null;
var falseLabel = il.DefineLabel();
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitCall(MessagePackBinaryTypeInfo.IsNil);
il.Emit(OpCodes.Brfalse_S, falseLabel);
if (ti.IsClass)
{
il.EmitLdarg(4);
il.EmitLdc_I4(1);
il.Emit(OpCodes.Stind_I4);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ret);
}
else
{
il.Emit(OpCodes.Ldstr, "typecode is null, struct not supported");
il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
il.Emit(OpCodes.Throw);
}
// read-array header and validate, ReadArrayHeader(bytes, offset, out readSize) != 2) throw;
il.MarkLabel(falseLabel);
var startOffset = il.DeclareLocal(typeof(int));
il.EmitLdarg(2);
il.EmitStloc(startOffset);
var rightLabel = il.DefineLabel();
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitLdarg(4);
il.EmitCall(MessagePackBinaryTypeInfo.ReadArrayHeader);
il.EmitLdc_I4(2);
il.Emit(OpCodes.Beq_S, rightLabel);
il.Emit(OpCodes.Ldstr, "Invalid Union data was detected. Type:" + type.FullName);
il.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
il.Emit(OpCodes.Throw);
il.MarkLabel(rightLabel);
EmitOffsetPlusReadSize(il);
// read key
var key = il.DeclareLocal(typeof(int));
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitLdarg(4);
il.EmitCall(MessagePackBinaryTypeInfo.ReadInt32);
il.EmitStloc(key);
EmitOffsetPlusReadSize(il);
// switch->read
var result = il.DeclareLocal(type);
var loopEnd = il.DefineLabel();
if (ti.IsClass)
{
il.Emit(OpCodes.Ldnull);
il.EmitStloc(result);
}
il.Emit(OpCodes.Ldloc, key);
var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Info = x }).ToArray();
il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());
// default
il.EmitLdarg(2);
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitCall(MessagePackBinaryTypeInfo.ReadNextBlock);
il.Emit(OpCodes.Add);
il.EmitStarg(2);
il.Emit(OpCodes.Br, loopEnd);
foreach (var item in switchLabels)
{
il.MarkLabel(item.Label);
EmitDeserializeUnionCase(il, type, UnionSerializationInfo.CreateOrNull(type, item.Info), key, stringByteKeysFields[item.Info.Tag]);
il.Emit(OpCodes.Stloc, result);
il.Emit(OpCodes.Br, loopEnd);
}
il.MarkLabel(loopEnd);
// finish readSize = offset - startOffset;
il.EmitLdarg(4);
il.EmitLdarg(2);
il.EmitLdloc(startOffset);
il.Emit(OpCodes.Sub);
il.Emit(OpCodes.Stind_I4);
il.Emit(OpCodes.Ldloc, result);
il.Emit(OpCodes.Ret);
}
// void Serialize(ref [arg:1]MessagePackWriter writer, [arg:2]T value, [arg:3]MessagePackSerializerOptions options);
static void BuildSerialize(
Type type,
UnionCaseInfo[] infos,
MethodBuilder method,
FieldBuilder[] stringByteKeysFields,
ILGenerator il,
int firstArgIndex
)
{
var tag = getTag(type);
var ti = type.GetTypeInfo();
var argWriter = new ArgumentField(il, firstArgIndex);
var argValue = new ArgumentField(il, firstArgIndex + 1, type);
var argOptions = new ArgumentField(il, firstArgIndex + 2);
// if(value == null) return WriteNil
if (ti.IsClass)
{
Label elseBody = il.DefineLabel();
argValue.EmitLoad();
il.Emit(OpCodes.Brtrue_S, elseBody);
argWriter.EmitLoad();
il.EmitCall(MessagePackWriterTypeInfo.WriteNil);
il.Emit(OpCodes.Ret);
il.MarkLabel(elseBody);
}
// IMessagePackSerializationCallbackReceiver.OnBeforeSerialize()
if (ti.ImplementedInterfaces.Any(x => x == typeof(IMessagePackSerializationCallbackReceiver)))
{
// call directly
MethodInfo[] runtimeMethods = type.GetRuntimeMethods().Where(x => x.Name == "OnBeforeSerialize").ToArray();
if (runtimeMethods.Length == 1)
{
argValue.EmitLoad();
il.Emit(OpCodes.Call, runtimeMethods[0]); // don't use EmitCall helper(must use 'Call')
}
else
{
argValue.EmitLdarg(); // force ldarg
il.EmitBoxOrDoNothing(type);
il.EmitCall(onBeforeSerialize);
}
}
// IFormatterResolver resolver = options.Resolver;
LocalBuilder localResolver = il.DeclareLocal(typeof(IFormatterResolver));
argOptions.EmitLoad();
il.EmitCall(getResolverFromOptions);
il.EmitStloc(localResolver);
// writer.WriteArrayHeader(2, false);
argWriter.EmitLdarg();
il.EmitLdc_I4(2);
il.EmitCall(MessagePackWriterTypeInfo.WriteArrayHeader);
// writer.Write(value.Tag)
argWriter.EmitLdarg();
if (ti.IsClass)
{
argValue.EmitLdarg();
}
else
{
argValue.EmitLdarga();
}
il.EmitCall(tag);
il.EmitCall(MessagePackWriterTypeInfo.WriteInt32);
var loopEnd = il.DefineLabel();
// switch-case (offset += resolver.GetFormatter.Serialize(with cast)
var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Info = x }).ToArray();
if (ti.IsClass)
{
argValue.EmitLdarg();
}
else
{
argValue.EmitLdarga();
}
il.EmitCall(tag);
il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());
il.Emit(OpCodes.Br, loopEnd); // default
foreach (var item in switchLabels)
{
il.MarkLabel(item.Label);
EmitSerializeUnionCase(
il,
type,
ti,
UnionSerializationInfo.CreateOrNull(type, item.Info),
stringByteKeysFields[item.Info.Tag],
argWriter,
argValue,
argOptions,
localResolver
);
il.Emit(OpCodes.Br, loopEnd);
}
// return;
il.MarkLabel(loopEnd);
il.Emit(OpCodes.Ret);
}
// int Serialize([arg:1]ref byte[] bytes, [arg:2]int offset, [arg:3]T value, [arg:4]IFormatterResolver formatterResolver);
static void BuildSerialize(Type type, Microsoft.FSharp.Reflection.UnionCaseInfo[] infos, MethodBuilder method, FieldBuilder[] stringByteKeysFields, ILGenerator il)
{
var tag = getTag(type);
var ti = type.GetTypeInfo();
// if(value == null) return WriteNil
var elseBody = il.DefineLabel();
var notFoundType = il.DefineLabel();
il.EmitLoadArg(ti, 3);
il.Emit(OpCodes.Brtrue_S, elseBody);
il.Emit(OpCodes.Br, notFoundType);
il.MarkLabel(elseBody);
// var startOffset = offset;
var startOffsetLocal = il.DeclareLocal(typeof(int));
il.EmitLdarg(2);
il.EmitStloc(startOffsetLocal);
// offset += WriteFixedArrayHeaderUnsafe(,,2);
EmitOffsetPlusEqual(il, null, () =>
{
il.EmitLdc_I4(2);
il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedArrayHeaderUnsafe);
});
// offset += WriteInt32(,,value.Tag)
EmitOffsetPlusEqual(il, null, () =>
{
il.EmitLoadArg(ti, 3);
il.EmitCall(tag);
il.EmitCall(MessagePackBinaryTypeInfo.WriteInt32);
});
var loopEnd = il.DefineLabel();
// switch-case (offset += resolver.GetFormatter.Serialize(with cast)
var switchLabels = infos.Select(x => new { Label = il.DefineLabel(), Info = x }).ToArray();
il.EmitLoadArg(ti, 3);
il.EmitCall(tag);
il.Emit(OpCodes.Switch, switchLabels.Select(x => x.Label).ToArray());
il.Emit(OpCodes.Br, loopEnd); // default
foreach (var item in switchLabels)
{
il.MarkLabel(item.Label);
EmitSerializeUnionCase(il, type, ti, UnionSerializationInfo.CreateOrNull(type, item.Info), stringByteKeysFields[item.Info.Tag]);
il.Emit(OpCodes.Br, loopEnd);
}
// return startOffset- offset;
il.MarkLabel(loopEnd);
il.EmitLdarg(2);
il.EmitLdloc(startOffsetLocal);
il.Emit(OpCodes.Sub);
il.Emit(OpCodes.Ret);
// else, return WriteNil
il.MarkLabel(notFoundType);
il.EmitLdarg(1);
il.EmitLdarg(2);
il.EmitCall(MessagePackBinaryTypeInfo.WriteNil);
il.Emit(OpCodes.Ret);
}