public void Serialize(ref MessagePackWriter writer, ref int idx, CultureInfo value, IFormatterResolver formatterResolver)
{
if (value != null)
{
var encodedBytes = MessagePackBinary.GetEncodedStringBytes(value.Name);
UnsafeMemory.WriteRaw(ref writer, encodedBytes, ref idx);
return;
}
writer.WriteNil(ref idx);
}
public void Serialize(ref MessagePackWriter writer, ref int idx, T value, IFormatterResolver formatterResolver)
{
if (!valueNameMapping.TryGetValue(value, out string name))
{
name = value.ToString(); // fallback for flags etc, But Enum.ToString is too slow.
}
var encodedName = MessagePackBinary.GetEncodedStringBytes(name);
UnsafeMemory.WriteRaw(ref writer, encodedName, ref idx);
}
public void GetEncodedStringBytes(char c, int count)
{
var s = new string(c, count);
var bin1 = MessagePackBinary.GetEncodedStringBytes(s);
var bin2 = MessagePackSerializer.Serialize(s);
byte[] bin3 = null;
var size = MessagePackBinary.WriteRaw(ref bin3, 0, bin1);
MessagePackBinary.FastResize(ref bin3, size);
MessagePack.Internal.ByteArrayComparer.Equals(bin1, 0, bin1.Length, bin2).IsTrue();
MessagePack.Internal.ByteArrayComparer.Equals(bin1, 0, bin1.Length, bin3).IsTrue();
}
public void GetEncodedStringBytes(char c, int count)
{
var s = new string(c, count);
var bin1 = MessagePackBinary.GetEncodedStringBytes(s);
var bin2 = MessagePackSerializer.Serialize(s);
var idx = 0;
var writer = new MessagePackWriter(16);
writer.WriteRawBytes(bin1, ref idx);
MessagePack.Internal.ByteArrayComparer.Equals(bin1, 0, bin1.Length, bin2).IsTrue();
var buf = writer.ToArray(idx);
MessagePack.Internal.ByteArrayComparer.Equals(bin1, 0, bin1.Length, buf, 0, buf.Length).IsTrue();
}
public int Serialize(ref byte[] bytes, int offset, T value, IFormatterResolver formatterResolver)
{
if (value == null)
{
return(MessagePackBinary.WriteNil(ref bytes, offset));
}
var stringAsBytes = _typeByteNameLookup.GetOrAdd(value, type =>
{
var shortName = type.GetShortAssemblyQualifiedName();
_macroses.ForEach(x =>
{
shortName = shortName.Replace(x.Key, x.Value);
});
var byteArr = new ByteArrayKey(MessagePackBinary.GetEncodedStringBytes(shortName));
_byteTypeNameLookup.TryAdd(byteArr, type); //add to reverse cache
return(byteArr.Bytes);
});
return(MessagePackBinary.WriteBytes(ref bytes, offset, stringAsBytes));
}
static void EmitSerializeUnionCase(ILGenerator il, Type type, TypeInfo ti, UnionSerializationInfo info, FieldBuilder stringByteKeysField)
{
// IMessagePackSerializationCallbackReceiver.OnBeforeSerialize()
if (ti.ImplementedInterfaces.Any(x => x == typeof(IMessagePackSerializationCallbackReceiver)))
{
// call directly
var runtimeMethods = type.GetRuntimeMethods().Where(x => x.Name == "OnBeforeSerialize").ToArray();
if (runtimeMethods.Length == 1)
{
il.EmitLoadArg(ti, 3);
il.Emit(OpCodes.Call, runtimeMethods[0]); // don't use EmitCall helper(must use 'Call')
}
else
{
il.EmitLoadArg(ti, 3);
if (info.IsStruct)
{
il.Emit(OpCodes.Box, type);
}
il.EmitCall(onBeforeSerialize);
}
}
if (info.IsIntKey)
{
// use Array
var maxKey = info.Members.Select(x => x.IntKey).DefaultIfEmpty(0).Max();
var intKeyMap = info.Members.ToDictionary(x => x.IntKey);
EmitOffsetPlusEqual(il, null, () =>
{
var len = maxKey + 1;
il.EmitLdc_I4(len);
if (len <= MessagePackRange.MaxFixArrayCount)
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedArrayHeaderUnsafe);
}
else
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteArrayHeader);
}
});
for (int i = 0; i <= maxKey; i++)
{
UnionSerializationInfo.EmittableMember member;
if (intKeyMap.TryGetValue(i, out member))
{
// offset += serialzie
EmitSerializeValue(il, ti, member);
}
else
{
// Write Nil as Blanc
EmitOffsetPlusEqual(il, null, () =>
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteNil);
});
}
}
}
else
{
// use Map
var writeCount = info.Members.Count();
EmitOffsetPlusEqual(il, null, () =>
{
il.EmitLdc_I4(writeCount);
if (writeCount <= MessagePackRange.MaxFixMapCount)
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteFixedMapHeaderUnsafe);
}
else
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteMapHeader);
}
});
var index = 0;
foreach (var item in info.Members)
{
// offset += writekey
EmitOffsetPlusEqual(il, null, () =>
{
il.EmitLdarg(0);
il.EmitLdfld(stringByteKeysField);
il.EmitLdc_I4(index);
il.Emit(OpCodes.Ldelem_Ref);
// Optimize, WriteRaw(Unity, large) or UnsafeMemory32/64.WriteRawX
#if NETSTANDARD
var valueLen = MessagePackBinary.GetEncodedStringBytes(item.StringKey).Length;
if (valueLen <= MessagePackRange.MaxFixStringLength)
{
if (UnsafeMemory.Is32Bit)
{
il.EmitCall(typeof(UnsafeMemory32).GetRuntimeMethod("WriteRaw" + valueLen, new[] { refByte, typeof(int), typeof(byte[]) }));
}
else
{
il.EmitCall(typeof(UnsafeMemory64).GetRuntimeMethod("WriteRaw" + valueLen, new[] { refByte, typeof(int), typeof(byte[]) }));
}
}
else
#endif
{
il.EmitCall(MessagePackBinaryTypeInfo.WriteRaw);
}
index++;
});
// offset += serialzie
EmitSerializeValue(il, ti, item);
}
}
}
