public static IMessagePackFormatter <T> GetFormatterWithVerify <T>(this IFormatterResolver resolver)
{
IMessagePackFormatter <T> formatter;
try
{
formatter = resolver.GetFormatter <T>();
}
catch (TypeInitializationException ex)
{
Exception inner = ex;
while (inner.InnerException != null)
{
inner = inner.InnerException;
}
throw inner;
}
if (formatter == null)
{
throw new FormatterNotRegisteredException(typeof(T).FullName +
" is not registered in this resolver. resolver:" +
resolver.GetType().Name);
}
return(formatter);
}
public static IMessagePackFormatter <T> GetFormatterWithVerify <T>(this IFormatterResolver resolver)
{
var formatter = resolver.GetFormatter <T>();
if (formatter == null)
{
throw new FormatterNotRegisteredException(typeof(T).FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
}
return(formatter);
}
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();
var ti = type.GetTypeInfo();
if ((PrimitiveObjectFormatter.IsSupportedType(type, ti, value) &&
!(value is DateTime) &&
!(value is IDictionary) &&
!(value is ICollection)) ||
ti.IsAnonymous())
{
return(DynamicObjectTypeFallbackFormatter.Instance.Serialize(ref bytes, offset, value, formatterResolver));
}
var typeName = BuildTypeName(type);
if (blacklistCheck.Contains(type.FullName))
{
throw new InvalidOperationException("Type is in blacklist:" + type.FullName);
}
KeyValuePair <object, SerializeMethod> formatterAndDelegate;
if (type == typeof(object))
{
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(null, (object p1, ref byte[] p2, int p3, object p4, IFormatterResolver p5) => 0);
}
else
{
lock (serializers)
{
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
var formatter = formatterResolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name);
}
var formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
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), type, typeof(IFormatterResolver) });
var body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethodInfo,
param1,
param2,
ti.IsValueType ? Expression.Unbox(param3, type) : Expression.Convert(param3, type),
param4);
var lambda = Expression.Lambda <SerializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(formatter, lambda);
serializers[type] = 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.WriteString(ref bytes, offset, typeName);
offset += formatterAndDelegate.Value(formatterAndDelegate.Key, ref bytes, offset, value, formatterResolver);
MessagePackBinary.WriteExtensionFormatHeaderForceExt32Block(ref bytes, startOffset, (sbyte)TypelessFormatter.ExtensionTypeCode, offset - startOffset - 6);
return(offset - startOffset);
}
/// <summary>
/// Does not support deserializing of anonymous types
/// Type should be covered by preceeding resolvers in complex/standard resolver
/// </summary>
private object DeserializeByTypeName(string typeName, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
// try get type with assembly name, throw if not found
var type = Type.GetType(typeName, true);
var ti = type.GetTypeInfo();
KeyValuePair <object, DeserializeMethod> formatterAndDelegate;
if (type == typeof(object))
{
formatterAndDelegate = new KeyValuePair <object, DeserializeMethod>(null, (object p1, byte[] p2, int p3, IFormatterResolver p4, out int p5) =>
{
p5 = 0;
return(new object());
});
}
else
{
lock (deserializers)
{
if (!deserializers.TryGetValue(type, out formatterAndDelegate))
{
var formatter = formatterResolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name);
}
var formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
var param0 = Expression.Parameter(typeof(object), "formatter");
var param1 = Expression.Parameter(typeof(byte[]), "bytes");
var param2 = Expression.Parameter(typeof(int), "offset");
var param3 = Expression.Parameter(typeof(IFormatterResolver), "formatterResolver");
var param4 = Expression.Parameter(typeof(int).MakeByRefType(), "readSize");
var deserializeMethodInfo = formatterType.GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() });
var deserialize = Expression.Call(
Expression.Convert(param0, formatterType),
deserializeMethodInfo,
param1,
param2,
param3,
param4);
Expression body = deserialize;
if (ti.IsValueType)
{
body = Expression.Convert(deserialize, typeof(object));
}
var lambda = Expression.Lambda <DeserializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, DeserializeMethod>(formatter, lambda);
deserializers[type] = formatterAndDelegate;
}
}
}
return(formatterAndDelegate.Value(formatterAndDelegate.Key, bytes, offset, formatterResolver, out readSize));
}
/// <summary>
/// Does not support deserializing of anonymous types
/// Type should be covered by preceeding resolvers in complex/standard resolver.
/// </summary>
private object DeserializeByTypeName(ArraySegment <byte> typeName, ref MessagePackReader byteSequence, MessagePackSerializerOptions options)
{
// try get type with assembly name, throw if not found
Type type;
if (!this.typeCache.TryGetValue(typeName, out type))
{
var buffer = new byte[typeName.Count];
Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length);
var str = StringEncoding.UTF8.GetString(buffer);
type = this.BindToType(str);
if (type == null)
{
if (IsMscorlib && str.Contains("System.Private.CoreLib"))
{
str = str.Replace("System.Private.CoreLib", "mscorlib");
type = Type.GetType(str, true); // throw
}
else if (!IsMscorlib && str.Contains("mscorlib"))
{
str = str.Replace("mscorlib", "System.Private.CoreLib");
type = Type.GetType(str, true); // throw
}
else
{
type = Type.GetType(str, true); // re-throw
}
}
this.typeCache.TryAdd(buffer, type);
}
KeyValuePair <object, DeserializeMethod> formatterAndDelegate;
if (!this.deserializers.TryGetValue(type, out formatterAndDelegate))
{
lock (this.deserializers)
{
if (!this.deserializers.TryGetValue(type, out formatterAndDelegate))
{
TypeInfo ti = type.GetTypeInfo();
IFormatterResolver resolver = options.Resolver;
var formatter = resolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
}
Type formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
ParameterExpression param1 = Expression.Parameter(typeof(MessagePackReader).MakeByRefType(), "reader");
ParameterExpression param2 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
MethodInfo deserializeMethodInfo = formatterType.GetRuntimeMethod("Deserialize", new[] { typeof(MessagePackReader).MakeByRefType(), typeof(MessagePackSerializerOptions) });
MethodCallExpression deserialize = Expression.Call(
Expression.Convert(param0, formatterType),
deserializeMethodInfo,
param1,
param2);
Expression body = deserialize;
if (ti.IsValueType)
{
body = Expression.Convert(deserialize, typeof(object));
}
DeserializeMethod lambda = Expression.Lambda <DeserializeMethod>(body, param0, param1, param2).Compile();
formatterAndDelegate = new KeyValuePair <object, DeserializeMethod>(formatter, lambda);
this.deserializers.TryAdd(type, formatterAndDelegate);
}
}
}
return(formatterAndDelegate.Value(formatterAndDelegate.Key, ref byteSequence, options));
}
public void Serialize(ref MessagePackWriter writer, object value, MessagePackSerializerOptions options)
{
if (value == null)
{
writer.WriteNil();
return;
}
Type type = value.GetType();
byte[] typeName;
if (!this.typeNameCache.TryGetValue(type, out typeName))
{
if (BlacklistCheck.Contains(type.FullName))
{
throw new InvalidOperationException("Type is in blacklist:" + type.FullName);
}
TypeInfo ti = type.GetTypeInfo();
if (ti.IsAnonymous() || UseBuiltinTypes.Contains(type))
{
typeName = null;
}
else
{
typeName = StringEncoding.UTF8.GetBytes(this.BuildTypeName(type));
}
this.typeNameCache.TryAdd(type, typeName);
}
if (typeName == null)
{
Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter <object>().Serialize(ref writer, value, options);
return;
}
// don't use GetOrAdd for avoid closure capture.
KeyValuePair <object, SerializeMethod> formatterAndDelegate;
if (!this.serializers.TryGetValue(type, out formatterAndDelegate))
{
// double check locking...
lock (this.serializers)
{
if (!this.serializers.TryGetValue(type, out formatterAndDelegate))
{
TypeInfo ti = type.GetTypeInfo();
IFormatterResolver resolver = options.Resolver;
var formatter = resolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
}
Type formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
ParameterExpression param1 = Expression.Parameter(typeof(MessagePackWriter).MakeByRefType(), "writer");
ParameterExpression param2 = Expression.Parameter(typeof(object), "value");
ParameterExpression param3 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
MethodInfo serializeMethodInfo = formatterType.GetRuntimeMethod("Serialize", new[] { typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) });
MethodCallExpression body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethodInfo,
param1,
ti.IsValueType ? Expression.Unbox(param2, type) : Expression.Convert(param2, type),
param3);
SerializeMethod lambda = Expression.Lambda <SerializeMethod>(body, param0, param1, param2, param3).Compile();
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(formatter, lambda);
this.serializers.TryAdd(type, formatterAndDelegate);
}
}
}
// mark will be written at the end, when size is known
using (var scratch = new Nerdbank.Streams.Sequence <byte>())
{
MessagePackWriter scratchWriter = writer.Clone(scratch);
scratchWriter.WriteString(typeName);
formatterAndDelegate.Value(formatterAndDelegate.Key, ref scratchWriter, value, options);
scratchWriter.Flush();
// mark as extension with code 100
writer.WriteExtensionFormat(new ExtensionResult((sbyte)TypelessFormatter.ExtensionTypeCode, scratch.AsReadOnlySequence));
}
}
internal static void ThrowFormatterNotRegistered(Type type, IFormatterResolver resolver)
{
throw new BssomSerializationTypeFormatterException($"{type.Name}没有在{resolver.GetType().Name}中进行注册. {type.Name} is not registered in {resolver.GetType().Name}");
}
internal static void ThrowFormatterNotRegisteredException(Type type, IFormatterResolver formatterResolver)
{
throw GetException();
Exception GetException()
{
return(new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name));
}
}
public static IMessagePackFormatter <T> GetFormatterWithVerify <T>(this IFormatterResolver resolver)
{
IMessagePackFormatter <T> formatter;
try
{
formatter = resolver.GetFormatter <T>();
}
catch (TypeInitializationException ex)
{
// The fact that we're using static constructors to initialize this is an internal detail.
// Rethrow the inner exception if there is one.
// Do it carefully so as to not stomp on the original callstack.
ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
throw new InvalidOperationException("Unreachable"); // keep the compiler happy
}
if (formatter == null)
{
throw new FormatterNotRegisteredException(typeof(T).FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
}
return(formatter);
}
private static void ThrowFormatterNotRegisteredException <T>(IFormatterResolver resolver)
{
throw GetException();
FormatterNotRegisteredException GetException()
{
return(new FormatterNotRegisteredException(typeof(T).FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name));
}
}
public static IMessagePackFormatter <T> GetFormatterWithVerify <T>(this IFormatterResolver resolver)
{
IMessagePackFormatter <T> formatter;
try
{
formatter = resolver.GetFormatter <T>();
}
catch (TypeInitializationException ex)
{
#if NETSTANDARD || NETFRAMEWORK || NETCOREAPP
// The fact that we're using static constructors to initialize this is an internal detail.
// Rethrow the inner exception if there is one.
// Do it carefully so as to not stomp on the original callstack.
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
throw new InvalidOperationException("Unreachable"); // keep the compiler happy
#else
var data = ex.Data; // suppress warning about not using `ex`
throw;
#endif
}
if (formatter == null)
{
throw new FormatterNotRegisteredException(typeof(T).FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
}
return(formatter);
}
/// <summary>
/// Does not support deserializing of anonymous types
/// Type should be covered by preceeding resolvers in complex/standard resolver
/// </summary>
private object DeserializeByTypeName(ArraySegment <byte> typeName, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
// try get type with assembly name, throw if not found
Type type;
if (!typeCache.TryGetValue(typeName, out type))
{
var buffer = new byte[typeName.Count];
Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length);
var str = StringEncoding.UTF8.GetString(buffer);
type = BindToType(str);
if (type == null)
{
if (isMscorlib && str.Contains("System.Private.CoreLib"))
{
str = str.Replace("System.Private.CoreLib", "mscorlib");
type = Type.GetType(str, true); // throw
}
else if (!isMscorlib && str.Contains("mscorlib"))
{
str = str.Replace("mscorlib", "System.Private.CoreLib");
type = Type.GetType(str, true); // throw
}
else
{
type = Type.GetType(str, true); // re-throw
}
}
typeCache.TryAdd(buffer, type);
}
KeyValuePair <object, DeserializeMethod> formatterAndDelegate;
if (!deserializers.TryGetValue(type, out formatterAndDelegate))
{
lock (deserializers)
{
if (!deserializers.TryGetValue(type, out formatterAndDelegate))
{
var ti = type.GetTypeInfo();
var formatter = formatterResolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name);
}
var formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
var param0 = Expression.Parameter(typeof(object), "formatter");
var param1 = Expression.Parameter(typeof(byte[]), "bytes");
var param2 = Expression.Parameter(typeof(int), "offset");
var param3 = Expression.Parameter(typeof(IFormatterResolver), "formatterResolver");
var param4 = Expression.Parameter(typeof(int).MakeByRefType(), "readSize");
var deserializeMethodInfo = formatterType.GetRuntimeMethod("Deserialize", new[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() });
var deserialize = Expression.Call(
Expression.Convert(param0, formatterType),
deserializeMethodInfo,
param1,
param2,
param3,
param4);
Expression body = deserialize;
if (ti.IsValueType)
{
body = Expression.Convert(deserialize, typeof(object));
}
var lambda = Expression.Lambda <DeserializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, DeserializeMethod>(formatter, lambda);
deserializers.TryAdd(type, formatterAndDelegate);
}
}
}
return(formatterAndDelegate.Value(formatterAndDelegate.Key, bytes, offset, formatterResolver, out readSize));
}
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();
byte[] typeName;
if (!typeNameCache.TryGetValue(type, out typeName))
{
if (blacklistCheck.Contains(type.FullName))
{
throw new InvalidOperationException("Type is in blacklist:" + type.FullName);
}
var ti = type.GetTypeInfo();
if (ti.IsAnonymous() || useBuiltinTypes.Contains(type))
{
typeName = null;
}
else
{
typeName = StringEncoding.UTF8.GetBytes(BuildTypeName(type));
}
typeNameCache.TryAdd(type, typeName);
}
if (typeName == null)
{
return(Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter <object>().Serialize(ref bytes, offset, value, formatterResolver));
}
// don't use GetOrAdd for avoid closure capture.
KeyValuePair <object, SerializeMethod> formatterAndDelegate;
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
lock (serializers) // double check locking...
{
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
var ti = type.GetTypeInfo();
var formatter = formatterResolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name);
}
var formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(type);
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), type, typeof(IFormatterResolver) });
var body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethodInfo,
param1,
param2,
ti.IsValueType ? Expression.Unbox(param3, type) : Expression.Convert(param3, type),
param4);
var lambda = Expression.Lambda <SerializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(formatter, lambda);
serializers.TryAdd(type, 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, (sbyte)TypelessFormatter.ExtensionTypeCode, offset - startOffset - 6);
return(offset - startOffset);
}
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();
var ti = type.GetTypeInfo();
if (type == typeof(object))
{
// serialize to empty map
return(MessagePackBinary.WriteMapHeader(ref bytes, offset, 0));
}
KeyValuePair <object, SerializeMethod> formatterAndDelegate;
lock (serializers)
{
if (!serializers.TryGetValue(type, out formatterAndDelegate))
{
var formatter = formatterResolver.GetFormatterDynamic(type);
if (formatter == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + formatterResolver.GetType().Name);
}
serializers.TryAdd(type, t =>
{
var formatterType = typeof(IMessagePackFormatter <>).MakeGenericType(t);
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), t, typeof(IFormatterResolver) });
var body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethodInfo,
param1,
param2,
ti.IsValueType ? Expression.Unbox(param3, t) : Expression.Convert(param3, t),
param4);
var lambda = Expression.Lambda <SerializeMethod>(body, param0, param1, param2, param3, param4).Compile();
formatterAndDelegate = new KeyValuePair <object, SerializeMethod>(formatter, lambda);
return(formatterAndDelegate);
});
}
}
return(formatterAndDelegate.Value(formatterAndDelegate.Key, ref bytes, offset, value, formatterResolver));
}
public static IJsonFormatter <T> GetFormatterWithVerify <T>(this IFormatterResolver resolver)
{
#if CSHARP_8_OR_NEWER
IJsonFormatter <T>?formatter;
#else
IJsonFormatter <T> formatter;
#endif
try
{
formatter = resolver.GetFormatter <T>();
}
catch (TypeInitializationException ex)
{
// The fact that we're using static constructors to initialize this is an internal detail.
// Rethrow the inner exception if there is one.
// Do it carefully so as to not stomp on the original callstack.
ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
throw new InvalidOperationException();
}
if (formatter == null)
{
throw new FormatterNotRegisteredException(typeof(T).FullName + " is not registered in resolver: " + resolver.GetType());
}
return(formatter);
}
internal static object GetFormatterDynamicWithVerify(this IFormatterResolver resolver, Type type)
{
var result = GetFormatterDynamic(resolver, type);
if (result == null)
{
throw new FormatterNotRegisteredException(type.FullName + " is not registered in resolver: " + resolver.GetType());
}
return(result);
}
