public int Serialize(ref byte[] bytes, int offset, Double value, IFormatterResolver formatterResolver)
{
return(MessagePackBinary.WriteDouble(ref bytes, offset, value));
}
public Double Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
return(MessagePackBinary.ReadDouble(bytes, offset, out readSize));
}
public int Serialize(ref byte[] bytes, int offset, IGrouping<TKey, TElement> value, IFormatterResolver formatterResolver)
{
if (value == null)
{
return MessagePackBinary.WriteNil(ref bytes, offset);
}
else
{
var startOffset = offset;
offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, 2);
offset += formatterResolver.GetFormatterWithVerify<TKey>().Serialize(ref bytes, offset, value.Key, formatterResolver);
offset += formatterResolver.GetFormatterWithVerify<IEnumerable<TElement>>().Serialize(ref bytes, offset, value, formatterResolver);
return offset - startOffset;
}
}
/// <summary>
/// Dump to JSON string.
/// </summary>
public static string ToJson <T>(T obj, IFormatterResolver resolver)
{
return(ToJson(Serialize(obj, resolver)));
}
public int Serialize(ref byte[] bytes, int offset, LockoutEndDateChanged value, IFormatterResolver formatterResolver)
{
if (value.LockoutEnd == null)
{
return(MessagePackBinary.WriteNil(ref bytes, offset));
}
return(MessagePackBinary.WriteDateTime(ref bytes, offset, value.LockoutEnd.Value.UtcDateTime));
}
public int Serialize(ref byte[] bytes, int offset, TCollection value, IFormatterResolver formatterResolver)
{
if (value == null)
{
return MessagePackBinary.WriteNil(ref bytes, offset);
}
else
{
// Optimize iteration(array is fastest)
var array = value as TElement[];
if (array != null)
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify<TElement>();
offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, array.Length);
foreach (var item in array)
{
offset += formatter.Serialize(ref bytes, offset, item, formatterResolver);
}
return offset - startOffset;
}
else
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify<TElement>();
// knows count or not.
var seqCount = GetCount(value);
if (seqCount != null)
{
offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, seqCount.Value);
// Unity's foreach struct enumerator causes boxing so iterate manually.
var e = GetSourceEnumerator(value);
try
{
while (e.MoveNext())
{
#if NETSTANDARD
offset += formatter.Serialize(ref bytes, offset, e.Current, formatterResolver);
#else
offset += formatter.Serialize(ref bytes, (int)offset, (TElement)e.Current, (IFormatterResolver)formatterResolver);
#endif
}
}
finally
{
e.Dispose();
}
return offset - startOffset;
}
else
{
// write message first -> open header space -> write header
var writeStarOffset = offset;
var count = 0;
var moveCount = 0;
// count = 16 <= 65535, header len is "3" so choose default space.
offset += 3;
var e = GetSourceEnumerator(value);
try
{
while (e.MoveNext())
{
count++;
#if NETSTANDARD
var writeSize = formatter.Serialize(ref bytes, offset, e.Current, formatterResolver);
#else
var writeSize = formatter.Serialize(ref bytes, (int)offset, (TElement)e.Current, (IFormatterResolver)formatterResolver);
#endif
moveCount += writeSize;
offset += writeSize;
}
}
finally
{
e.Dispose();
}
var headerLength = MessagePackBinary.GetArrayHeaderLength(count);
if (headerLength != 3)
{
if (headerLength == 1) offset -= 2; // 1
else offset += 2; // 5
MessagePackBinary.EnsureCapacity(ref bytes, offset, headerLength);
Buffer.BlockCopy(bytes, writeStarOffset + 3, bytes, writeStarOffset + headerLength, moveCount);
}
MessagePackBinary.WriteArrayHeader(ref bytes, writeStarOffset, count);
return offset - startOffset;
}
}
}
}
public static void RegisterDefaultResolver(params IFormatterResolver[] resolvers)
{
CompositeResolver.Register(resolvers);
defaultResolver = CompositeResolver.Instance;
}
//// see:http://msdn.microsoft.com/en-us/library/w3f99sx1.aspx
//// subtract Version, Culture and PublicKeyToken from AssemblyQualifiedName
//static string BuildTypeName(Type type)
//{
// if (RemoveAssemblyVersion)
// {
// string full = type.AssemblyQualifiedName;
// var shortened = SubtractFullNameRegex.Replace(full, "");
// if (Type.GetType(shortened, false) == null)
// {
// // if type cannot be found with shortened name - use full name
// shortened = full;
// }
// return shortened;
// }
// else
// {
// return type.AssemblyQualifiedName;
// }
//}
public int Serialize(ref byte[] bytes, int offset, object value, IFormatterResolver formatterResolver)
{
if (value == null)
{
return(MessagePackBinary.WriteNil(ref bytes, offset));
}
var type = value.GetType();
Type expectedType;
byte[] typeName;
if (typeNameCache.TryGetValue(type, out var typeAndName))
{
expectedType = typeAndName.Key;
typeName = typeAndName.Value;
}
else
{
if (blacklistCheck.Contains(type.FullName))
{
ThrowHelper.ThrowInvalidOperationException_Blacklist(type);
}
if (type.IsAnonymous() || useBuiltinTypes.Contains(type))
{
typeName = null;
expectedType = null;
}
else
{
typeName = TranslateTypeName(type, out expectedType);
}
typeNameCache.TryAdd(type, new KeyValuePair <Type, byte[]>(expectedType, typeName));
}
if (typeName == null)
{
return(Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter <object>().Serialize(ref bytes, offset, value, formatterResolver));
}
// don't use GetOrAdd for avoid closure capture.
if (!serializers.TryGetValue(expectedType, out var formatterAndDelegate))
{
lock (serializers) // double check locking...
{
if (!serializers.TryGetValue(expectedType, out formatterAndDelegate))
{
var formatter = formatterResolver.GetFormatterDynamic(expectedType);
if (formatter == null)
{
ThrowHelper.ThrowFormatterNotRegisteredException(expectedType, formatterResolver);
}
var formatterType = typeof(IMessagePackFormatter <>).GetCachedGenericType(expectedType);
var param0 = Expression.Parameter(typeof(object), "formatter");
var param1 = Expression.Parameter(typeof(byte[]).MakeByRefType(), "bytes");
var param2 = Expression.Parameter(typeof(int), "offset");
var param3 = Expression.Parameter(typeof(object), "value");
var param4 = Expression.Parameter(typeof(IFormatterResolver), "formatterResolver");
var serializeMethodInfo = formatterType.GetRuntimeMethod("Serialize", new[] { typeof(byte[]).MakeByRefType(), typeof(int), expectedType, typeof(IFormatterResolver) });
var body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethodInfo,
param1,
param2,
expectedType.IsValueType ? Expression.Unbox(param3, expectedType) : Expression.Convert(param3, expectedType),
param4);
var lambda = Expression.Lambda <SerializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(formatter, lambda);
serializers.TryAdd(expectedType, formatterAndDelegate);
}
}
}
// mark as extension with code 100
var startOffset = offset;
offset += 6; // mark will be written at the end, when size is known
offset += MessagePackBinary.WriteStringBytes(ref bytes, offset, typeName);
offset += formatterAndDelegate.Value(formatterAndDelegate.Key, ref bytes, offset, value, formatterResolver);
MessagePackBinary.WriteExtensionFormatHeaderForceExt32Block(ref bytes, startOffset, ExtensionTypeCode, offset - startOffset - 6);
return(offset - startOffset);
}
public static T Create(CallInvoker invoker, IFormatterResolver resolver)
{
return(consturtor(invoker, resolver));
}
public static T Create <T>(CallInvoker invoker, IFormatterResolver resolver)
where T : IService <T>
{
return(MagicOnionClientRegistry <T> .Create(invoker, resolver));
}
public static T Create <T>(Channel channel, IFormatterResolver resolver)
where T : IService <T>
{
return(Create <T>(new DefaultCallInvoker(channel), resolver));
}
protected virtual int SerializeBody(ref byte[] bytes, int offset, T instance, IFormatterResolver formatterResolver)
{
// [typeIndex, [members], [members], [members]]
var startOffset = offset;
var meta = DarkMeta.Get(instance.GetType());
if (meta.Flags.IsStatic())
{
offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, meta.DeepLevel);
}
else
{
offset += MessagePackBinary.WriteArrayHeader(ref bytes, offset, meta.DeepLevel + 1);
offset += MessagePackBinary.WriteInt32(ref bytes, offset, (int)meta.TypeIndex);
if (meta.TypeIndex == TypeIndex.Invalid)
{
var message = String.Format("Type index is invalid at {0} ", instance.ToString());
Logger.Instance.Error(message);
}
}
offset += meta.WriteMembers(Serializer.Instance.State.Settings.Flags, instance, ref bytes, offset, formatterResolver);
return(offset - startOffset);
}
protected virtual T DeserializeBody(Type type, int elementsCount, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
// ...[members], [members], [members]...
var meta = DarkMeta.Get(type);
var instance = meta.CreateInstance();
Serializer.Instance.State.ObjectInstances.Add(instance);
meta.ReadMembers(Serializer.Instance.State.Settings.Flags, ref instance, bytes, offset, formatterResolver, out readSize);
return((T)instance);
}
