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