Merge pull request MessagePack-CSharp#1100 from AArnott/fix1097

AArnott · web-flow · commit 1869199a93a8 · 2020-10-31T09:03:43.000-06:00
Fix `[MessagePackFormatter(TypelessFormatter)]`
diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/TypelessFormatter.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/TypelessFormatter.cs
@@ -50,11 +50,11 @@ public sealed class TypelessFormatter : IMessagePackFormatter<object>
         /// </summary>
         public static readonly IMessagePackFormatter<object> Instance = new TypelessFormatter();
 
-        private readonly ThreadsafeTypeKeyHashTable<SerializeMethod> serializers = new ThreadsafeTypeKeyHashTable<SerializeMethod>();
-        private readonly ThreadsafeTypeKeyHashTable<DeserializeMethod> deserializers = new ThreadsafeTypeKeyHashTable<DeserializeMethod>();
-        private readonly ThreadsafeTypeKeyHashTable<byte[]> fullTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();
-        private readonly ThreadsafeTypeKeyHashTable<byte[]> shortenedTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();
-        private readonly AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type> typeCache = new AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type>(new StringArraySegmentByteAscymmetricEqualityComparer());
+        private static readonly ThreadsafeTypeKeyHashTable<SerializeMethod> Serializers = new ThreadsafeTypeKeyHashTable<SerializeMethod>();
+        private static readonly ThreadsafeTypeKeyHashTable<DeserializeMethod> Deserializers = new ThreadsafeTypeKeyHashTable<DeserializeMethod>();
+        private static readonly ThreadsafeTypeKeyHashTable<byte[]> FullTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();
+        private static readonly ThreadsafeTypeKeyHashTable<byte[]> ShortenedTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();
+        private static readonly AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type> TypeCache = new AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type>(new StringArraySegmentByteAscymmetricEqualityComparer());
 
         private static readonly HashSet<Type> UseBuiltinTypes = new HashSet<Type>
         {
@@ -107,10 +107,10 @@ public sealed class TypelessFormatter : IMessagePackFormatter<object>
         // mscorlib or System.Private.CoreLib
         private static readonly bool IsMscorlib = typeof(int).AssemblyQualifiedName.Contains("mscorlib");
 
-        private TypelessFormatter()
+        static TypelessFormatter()
         {
-            this.serializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackWriter p2, object p3, MessagePackSerializerOptions p4) => { });
-            this.deserializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackReader p2, MessagePackSerializerOptions p3) => new object());
+            Serializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackWriter p2, object p3, MessagePackSerializerOptions p4) => { });
+            Deserializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackReader p2, MessagePackSerializerOptions p3) => new object());
         }
 
         private string BuildTypeName(Type type, MessagePackSerializerOptions options)
@@ -145,7 +145,7 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer
             Type type = value.GetType();
 
             byte[] typeName;
-            var typeNameCache = options.OmitAssemblyVersion ? this.shortenedTypeNameCache : this.fullTypeNameCache;
+            var typeNameCache = options.OmitAssemblyVersion ? ShortenedTypeNameCache : FullTypeNameCache;
             if (!typeNameCache.TryGetValue(type, out typeName))
             {
                 TypeInfo ti = type.GetTypeInfo();
@@ -170,12 +170,12 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer
             var formatter = options.Resolver.GetFormatterDynamicWithVerify(type);
 
             // don't use GetOrAdd for avoid closure capture.
-            if (!this.serializers.TryGetValue(type, out SerializeMethod serializeMethod))
+            if (!Serializers.TryGetValue(type, out SerializeMethod serializeMethod))
             {
                 // double check locking...
-                lock (this.serializers)
+                lock (Serializers)
                 {
-                    if (!this.serializers.TryGetValue(type, out serializeMethod))
+                    if (!Serializers.TryGetValue(type, out serializeMethod))
                     {
                         TypeInfo ti = type.GetTypeInfo();
 
@@ -196,7 +196,7 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer
 
                         serializeMethod = Expression.Lambda<SerializeMethod>(body, param0, param1, param2, param3).Compile();
 
-                        this.serializers.TryAdd(type, serializeMethod);
+                        Serializers.TryAdd(type, serializeMethod);
                     }
                 }
             }
@@ -263,7 +263,7 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac
         {
             // try get type with assembly name, throw if not found
             Type type;
-            if (!this.typeCache.TryGetValue(typeName, out type))
+            if (!TypeCache.TryGetValue(typeName, out type))
             {
                 var buffer = new byte[typeName.Count];
                 Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length);
@@ -287,18 +287,18 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac
                     }
                 }
 
-                this.typeCache.TryAdd(buffer, type);
+                TypeCache.TryAdd(buffer, type);
             }
 
             options.ThrowIfDeserializingTypeIsDisallowed(type);
 
             var formatter = options.Resolver.GetFormatterDynamicWithVerify(type);
 
-            if (!this.deserializers.TryGetValue(type, out DeserializeMethod deserializeMethod))
+            if (!Deserializers.TryGetValue(type, out DeserializeMethod deserializeMethod))
             {
-                lock (this.deserializers)
+                lock (Deserializers)
                 {
-                    if (!this.deserializers.TryGetValue(type, out deserializeMethod))
+                    if (!Deserializers.TryGetValue(type, out deserializeMethod))
                     {
                         TypeInfo ti = type.GetTypeInfo();
 
@@ -323,7 +323,7 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac
 
                         deserializeMethod = Expression.Lambda<DeserializeMethod>(body, param0, param1, param2).Compile();
 
-                        this.deserializers.TryAdd(type, deserializeMethod);
+                        Deserializers.TryAdd(type, deserializeMethod);
                     }
                 }
             }
diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSerializerTypelessTests.cs b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSerializerTypelessTests.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Runtime.Serialization;
 using MessagePack;
+using MessagePack.Formatters;
 using MessagePack.Resolvers;
 using Xunit;
 using Xunit.Abstractions;
@@ -104,6 +105,14 @@ public void PrimitiveIntTypePreservation(object boxedValue)
         Assert.IsType(boxedValue.GetType(), roundTripValue);
     }
 
+    [Fact]
+    public void TypelessFormatterAsAttribute()
+    {
+        byte[] msgpack = MessagePackSerializer.Serialize(new ClassWithTypelessField { Value = "hi" }, MessagePackSerializerOptions.Standard);
+        var deserialized = MessagePackSerializer.Deserialize<ClassWithTypelessField>(msgpack, MessagePackSerializerOptions.Standard);
+        Assert.Equal("hi", deserialized.Value);
+    }
+
     public class MyObject
     {
         public object SomeValue { get; set; }
@@ -165,6 +174,14 @@ public class TypelessNonAbstract : TypelessAbstract
     {
         public int Y { get; set; }
     }
+
+    [MessagePackObject]
+    public class ClassWithTypelessField
+    {
+        [Key("Value")]
+        [MessagePackFormatter(typeof(TypelessFormatter))]
+        public object Value;
+    }
 }
 
 #endif
diff --git a/src/MessagePack/PublicAPI.Unshipped.txt b/src/MessagePack/PublicAPI.Unshipped.txt
@@ -36,6 +36,7 @@ MessagePack.Formatters.ReadOnlySequenceFormatter<T>.Serialize(ref MessagePack.Me
 MessagePack.Formatters.TypeFormatter<T>
 MessagePack.Formatters.TypeFormatter<T>.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions options) -> T
 MessagePack.Formatters.TypeFormatter<T>.Serialize(ref MessagePack.MessagePackWriter writer, T value, MessagePack.MessagePackSerializerOptions options) -> void
+MessagePack.Formatters.TypelessFormatter.TypelessFormatter() -> void
 MessagePack.ImmutableCollection.ImmutableArrayFormatter<T>
 MessagePack.ImmutableCollection.ImmutableArrayFormatter<T>.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableArray<T>
 MessagePack.ImmutableCollection.ImmutableArrayFormatter<T>.ImmutableArrayFormatter() -> void

Original file line number	Diff line number	Diff line change
`@@ -50,11 +50,11 @@ public sealed class TypelessFormatter : IMessagePackFormatter<object>`
`50`	`50`	`/// </summary>`
`51`	`51`	`public static readonly IMessagePackFormatter<object> Instance = new TypelessFormatter();`
`52`	`52`
`53`		`- private readonly ThreadsafeTypeKeyHashTable<SerializeMethod> serializers = new ThreadsafeTypeKeyHashTable<SerializeMethod>();`
`54`		`- private readonly ThreadsafeTypeKeyHashTable<DeserializeMethod> deserializers = new ThreadsafeTypeKeyHashTable<DeserializeMethod>();`
`55`		`- private readonly ThreadsafeTypeKeyHashTable<byte[]> fullTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();`
`56`		`- private readonly ThreadsafeTypeKeyHashTable<byte[]> shortenedTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();`
`57`		`- private readonly AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type> typeCache = new AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type>(new StringArraySegmentByteAscymmetricEqualityComparer());`
	`53`	`+ private static readonly ThreadsafeTypeKeyHashTable<SerializeMethod> Serializers = new ThreadsafeTypeKeyHashTable<SerializeMethod>();`
	`54`	`+ private static readonly ThreadsafeTypeKeyHashTable<DeserializeMethod> Deserializers = new ThreadsafeTypeKeyHashTable<DeserializeMethod>();`
	`55`	`+ private static readonly ThreadsafeTypeKeyHashTable<byte[]> FullTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();`
	`56`	`+ private static readonly ThreadsafeTypeKeyHashTable<byte[]> ShortenedTypeNameCache = new ThreadsafeTypeKeyHashTable<byte[]>();`
	`57`	`+ private static readonly AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type> TypeCache = new AsymmetricKeyHashTable<byte[], ArraySegment<byte>, Type>(new StringArraySegmentByteAscymmetricEqualityComparer());`
`58`	`58`
`59`	`59`	`private static readonly HashSet<Type> UseBuiltinTypes = new HashSet<Type>`
`60`	`60`	`{`
`@@ -107,10 +107,10 @@ public sealed class TypelessFormatter : IMessagePackFormatter<object>`
`107`	`107`	`// mscorlib or System.Private.CoreLib`
`108`	`108`	`private static readonly bool IsMscorlib = typeof(int).AssemblyQualifiedName.Contains("mscorlib");`
`109`	`109`
`110`		`- private TypelessFormatter()`
	`110`	`+ static TypelessFormatter()`
`111`	`111`	`{`
`112`		`- this.serializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackWriter p2, object p3, MessagePackSerializerOptions p4) => { });`
`113`		`- this.deserializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackReader p2, MessagePackSerializerOptions p3) => new object());`
	`112`	`+ Serializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackWriter p2, object p3, MessagePackSerializerOptions p4) => { });`
	`113`	`+ Deserializers.TryAdd(typeof(object), _ => (object p1, ref MessagePackReader p2, MessagePackSerializerOptions p3) => new object());`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`private string BuildTypeName(Type type, MessagePackSerializerOptions options)`
`@@ -145,7 +145,7 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer`
`145`	`145`	`Type type = value.GetType();`
`146`	`146`
`147`	`147`	`byte[] typeName;`
`148`		`- var typeNameCache = options.OmitAssemblyVersion ? this.shortenedTypeNameCache : this.fullTypeNameCache;`
	`148`	`+ var typeNameCache = options.OmitAssemblyVersion ? ShortenedTypeNameCache : FullTypeNameCache;`
`149`	`149`	`if (!typeNameCache.TryGetValue(type, out typeName))`
`150`	`150`	`{`
`151`	`151`	`TypeInfo ti = type.GetTypeInfo();`
`@@ -170,12 +170,12 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer`
`170`	`170`	`var formatter = options.Resolver.GetFormatterDynamicWithVerify(type);`
`171`	`171`
`172`	`172`	`// don't use GetOrAdd for avoid closure capture.`
`173`		`- if (!this.serializers.TryGetValue(type, out SerializeMethod serializeMethod))`
	`173`	`+ if (!Serializers.TryGetValue(type, out SerializeMethod serializeMethod))`
`174`	`174`	`{`
`175`	`175`	`// double check locking...`
`176`		`- lock (this.serializers)`
	`176`	`+ lock (Serializers)`
`177`	`177`	`{`
`178`		`- if (!this.serializers.TryGetValue(type, out serializeMethod))`
	`178`	`+ if (!Serializers.TryGetValue(type, out serializeMethod))`
`179`	`179`	`{`
`180`	`180`	`TypeInfo ti = type.GetTypeInfo();`
`181`	`181`
`@@ -196,7 +196,7 @@ public void Serialize(ref MessagePackWriter writer, object value, MessagePackSer`
`196`	`196`
`197`	`197`	`serializeMethod = Expression.Lambda<SerializeMethod>(body, param0, param1, param2, param3).Compile();`
`198`	`198`
`199`		`- this.serializers.TryAdd(type, serializeMethod);`
	`199`	`+ Serializers.TryAdd(type, serializeMethod);`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`	`}`
`@@ -263,7 +263,7 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac`
`263`	`263`	`{`
`264`	`264`	`// try get type with assembly name, throw if not found`
`265`	`265`	`Type type;`
`266`		`- if (!this.typeCache.TryGetValue(typeName, out type))`
	`266`	`+ if (!TypeCache.TryGetValue(typeName, out type))`
`267`	`267`	`{`
`268`	`268`	`var buffer = new byte[typeName.Count];`
`269`	`269`	`Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length);`
`@@ -287,18 +287,18 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac`
`287`	`287`	`}`
`288`	`288`	`}`
`289`	`289`
`290`		`- this.typeCache.TryAdd(buffer, type);`
	`290`	`+ TypeCache.TryAdd(buffer, type);`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`options.ThrowIfDeserializingTypeIsDisallowed(type);`
`294`	`294`
`295`	`295`	`var formatter = options.Resolver.GetFormatterDynamicWithVerify(type);`
`296`	`296`
`297`		`- if (!this.deserializers.TryGetValue(type, out DeserializeMethod deserializeMethod))`
	`297`	`+ if (!Deserializers.TryGetValue(type, out DeserializeMethod deserializeMethod))`
`298`	`298`	`{`
`299`		`- lock (this.deserializers)`
	`299`	`+ lock (Deserializers)`
`300`	`300`	`{`
`301`		`- if (!this.deserializers.TryGetValue(type, out deserializeMethod))`
	`301`	`+ if (!Deserializers.TryGetValue(type, out deserializeMethod))`
`302`	`302`	`{`
`303`	`303`	`TypeInfo ti = type.GetTypeInfo();`
`304`	`304`
`@@ -323,7 +323,7 @@ private object DeserializeByTypeName(ArraySegment<byte> typeName, ref MessagePac`
`323`	`323`
`324`	`324`	`deserializeMethod = Expression.Lambda<DeserializeMethod>(body, param0, param1, param2).Compile();`
`325`	`325`
`326`		`- this.deserializers.TryAdd(type, deserializeMethod);`
	`326`	`+ Deserializers.TryAdd(type, deserializeMethod);`
`327`	`327`	`}`
`328`	`328`	`}`
`329`	`329`	`}`