Cache parameterized ctor delegates in class info rather than converter (#34248) (#34353)

layomia · web-flow · commit 8f6b899eaf9c · 2020-04-03T16:09:21.000-07:00
* Cache parameterized ctor delegates in class info rather than converter

* Address review feedback - move delegate assignment to start of deserialization

* Address review feedback - nullability
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs
@@ -12,45 +12,47 @@ namespace System.Text.Json.Serialization.Converters
     /// </summary>
     internal sealed class LargeObjectWithParameterizedConstructorConverter<T> : ObjectWithParameterizedConstructorConverter<T> where T : notnull
     {
-        private JsonClassInfo.ParameterizedConstructorDelegate<T>? _createObject;
-
-        internal override void CreateConstructorDelegate(JsonSerializerOptions options)
-        {
-            _createObject = options.MemberAccessorStrategy.CreateParameterizedConstructor<T>(ConstructorInfo)!;
-        }
-
         protected override bool ReadAndCacheConstructorArgument(ref ReadStack state, ref Utf8JsonReader reader, JsonParameterInfo jsonParameterInfo)
         {
             bool success = jsonParameterInfo.ReadJson(ref state, ref reader, out object? arg0);
 
             if (success)
             {
-                ((object[])state.Current.CtorArgumentState!.Arguments!)[jsonParameterInfo.Position] = arg0!;
+                ((object[])state.Current.CtorArgumentState!.Arguments)[jsonParameterInfo.Position] = arg0!;
             }
 
             return success;
         }
 
         protected override object CreateObject(ref ReadStackFrame frame)
         {
-            object[] arguments = (object[])frame.CtorArgumentState!.Arguments!;
+            object[] arguments = (object[])frame.CtorArgumentState!.Arguments;
+
+            var createObject = (JsonClassInfo.ParameterizedConstructorDelegate<T>?)frame.JsonClassInfo.CreateObjectWithParameterizedCtor;
 
-            if (_createObject == null)
+            if (createObject == null)
             {
                 // This means this constructor has more than 64 parameters.
-                ThrowHelper.ThrowNotSupportedException_ConstructorMaxOf64Parameters(ConstructorInfo, TypeToConvert);
+                ThrowHelper.ThrowNotSupportedException_ConstructorMaxOf64Parameters(ConstructorInfo!, TypeToConvert);
             }
 
-            object obj = _createObject(arguments)!;
+            object obj = createObject(arguments);
 
             ArrayPool<object>.Shared.Return(arguments, clearArray: true);
             return obj;
         }
 
         protected override void InitializeConstructorArgumentCaches(ref ReadStack state, JsonSerializerOptions options)
         {
-            object[] arguments = ArrayPool<object>.Shared.Rent(state.Current.JsonClassInfo.ParameterCount);
-            foreach (JsonParameterInfo jsonParameterInfo in state.Current.JsonClassInfo.ParameterCache!.Values)
+            JsonClassInfo classInfo = state.Current.JsonClassInfo;
+
+            if (classInfo.CreateObjectWithParameterizedCtor == null)
+            {
+                classInfo.CreateObjectWithParameterizedCtor = options.MemberAccessorStrategy.CreateParameterizedConstructor<T>(ConstructorInfo!);
+            }
+
+            object[] arguments = ArrayPool<object>.Shared.Rent(classInfo.ParameterCount);
+            foreach (JsonParameterInfo jsonParameterInfo in classInfo.ParameterCache!.Values)
             {
                 if (jsonParameterInfo.ShouldDeserialize)
                 {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs
@@ -12,17 +12,12 @@ namespace System.Text.Json.Serialization.Converters
     /// </summary>
     internal sealed class SmallObjectWithParameterizedConstructorConverter<T, TArg0, TArg1, TArg2, TArg3> : ObjectWithParameterizedConstructorConverter<T> where T : notnull
     {
-        private JsonClassInfo.ParameterizedConstructorDelegate<T, TArg0, TArg1, TArg2, TArg3>? _createObject;
-
-        internal override void CreateConstructorDelegate(JsonSerializerOptions options)
-        {
-            _createObject = options.MemberAccessorStrategy.CreateParameterizedConstructor<T, TArg0, TArg1, TArg2, TArg3>(ConstructorInfo)!;
-        }
-
         protected override object CreateObject(ref ReadStackFrame frame)
         {
-            var arguments = (Arguments<TArg0, TArg1, TArg2, TArg3>)frame.CtorArgumentState!.Arguments!;
-            return _createObject!(arguments.Arg0, arguments.Arg1, arguments.Arg2, arguments.Arg3)!;
+            var createObject = (JsonClassInfo.ParameterizedConstructorDelegate<T, TArg0, TArg1, TArg2, TArg3>)
+                frame.JsonClassInfo.CreateObjectWithParameterizedCtor!;
+            var arguments = (Arguments<TArg0, TArg1, TArg2, TArg3>)frame.CtorArgumentState!.Arguments;
+            return createObject!(arguments.Arg0, arguments.Arg1, arguments.Arg2, arguments.Arg3);
         }
 
         protected override bool ReadAndCacheConstructorArgument(ref ReadStack state, ref Utf8JsonReader reader, JsonParameterInfo jsonParameterInfo)
@@ -72,9 +67,17 @@ protected override bool ReadAndCacheConstructorArgument(ref ReadStack state, ref
 
         protected override void InitializeConstructorArgumentCaches(ref ReadStack state, JsonSerializerOptions options)
         {
+            JsonClassInfo classInfo = state.Current.JsonClassInfo;
+
+            if (classInfo.CreateObjectWithParameterizedCtor == null)
+            {
+                classInfo.CreateObjectWithParameterizedCtor =
+                    options.MemberAccessorStrategy.CreateParameterizedConstructor<T, TArg0, TArg1, TArg2, TArg3>(ConstructorInfo!);
+            }
+
             var arguments = new Arguments<TArg0, TArg1, TArg2, TArg3>();
 
-            foreach (JsonParameterInfo parameterInfo in state.Current.JsonClassInfo.ParameterCache!.Values)
+            foreach (JsonParameterInfo parameterInfo in classInfo.ParameterCache!.Values)
             {
                 if (parameterInfo.ShouldDeserialize)
                 {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs
@@ -429,7 +429,7 @@ private void BeginRead(ref ReadStack state, ref Utf8JsonReader reader, JsonSeria
 
             if (state.Current.JsonClassInfo.ParameterCount != state.Current.JsonClassInfo.ParameterCache!.Count)
             {
-                ThrowHelper.ThrowInvalidOperationException_ConstructorParameterIncompleteBinding(ConstructorInfo, TypeToConvert);
+                ThrowHelper.ThrowInvalidOperationException_ConstructorParameterIncompleteBinding(ConstructorInfo!, TypeToConvert);
             }
 
             // Set current JsonPropertyInfo to null to avoid conflicts on push.
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs
@@ -20,6 +20,8 @@ internal sealed partial class JsonClassInfo
 
         public ConstructorDelegate? CreateObject { get; private set; }
 
+        public object? CreateObjectWithParameterizedCtor { get; set; }
+
         public ClassType ClassType { get; private set; }
 
         public JsonPropertyInfo? DataExtensionProperty { get; private set; }
@@ -159,8 +161,7 @@ public JsonClassInfo(Type type, JsonSerializerOptions options)
 
                         if (converter.ConstructorIsParameterized)
                         {
-                            converter.CreateConstructorDelegate(options);
-                            InitializeConstructorParameters(converter.ConstructorInfo);
+                            InitializeConstructorParameters(converter.ConstructorInfo!);
                         }
                     }
                     break;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverter.cs
@@ -78,8 +78,6 @@ internal bool ShouldFlush(Utf8JsonWriter writer, ref WriteStack state)
         // Whether a type (ClassType.Object) is deserialized using a parameterized constructor.
         internal virtual bool ConstructorIsParameterized => false;
 
-        internal ConstructorInfo ConstructorInfo { get; set; } = null!;
-
-        internal virtual void CreateConstructorDelegate(JsonSerializerOptions options) { }
+        internal ConstructorInfo? ConstructorInfo { get; set; }
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/Serialization/ConstructorTests.Cache.cs b/src/libraries/System.Text.Json/tests/Serialization/ConstructorTests.Cache.cs
@@ -24,53 +24,66 @@ public void MultipleThreadsLooping()
         [Fact]
         public void MultipleThreads()
         {
-            // Use local options to avoid obtaining already cached metadata from the default options.
-            var options = new JsonSerializerOptions();
-
             // Verify the test class has >32 properties since that is a threshold for using the fallback dictionary.
             Assert.True(typeof(ClassWithConstructor_SimpleAndComplexParameters).GetProperties(BindingFlags.Instance | BindingFlags.Public).Length > 32);
 
-            void DeserializeObjectMinimal()
+            void DeserializeObject(string json, Type type, JsonSerializerOptions options)
+            {
+                var obj = Serializer.Deserialize(json, type, options);
+                ((ITestClassWithParameterizedCtor)obj).Verify();
+            }
+
+            void DeserializeObjectMinimal(Type type, JsonSerializerOptions options)
             {
-                var obj = Serializer.Deserialize<ClassWithConstructor_SimpleAndComplexParameters>(@"{""MyDecimal"" : 3.3}", options);
+                string json = (string)type.GetProperty("s_json_minimal").GetValue(null);
+                var obj = Serializer.Deserialize(json, type, options);
+                ((ITestClassWithParameterizedCtor)obj).VerifyMinimal();
             };
 
-            void DeserializeObjectFlipped()
+            void DeserializeObjectFlipped(Type type, JsonSerializerOptions options)
             {
-                var obj = Serializer.Deserialize<ClassWithConstructor_SimpleAndComplexParameters>(
-                    ClassWithConstructor_SimpleAndComplexParameters.s_json_flipped, options);
-                obj.Verify();
+                string json = (string)type.GetProperty("s_json_flipped").GetValue(null);
+                DeserializeObject(json, type, options);
             };
 
-            void DeserializeObjectNormal()
+            void DeserializeObjectNormal(Type type, JsonSerializerOptions options)
             {
-                var obj = Serializer.Deserialize<ClassWithConstructor_SimpleAndComplexParameters>(
-                    ClassWithConstructor_SimpleAndComplexParameters.s_json, options);
-                obj.Verify();
+                string json = (string)type.GetProperty("s_json").GetValue(null);
+                DeserializeObject(json, type, options);
             };
 
-            void SerializeObject()
+            void SerializeObject(Type type, JsonSerializerOptions options)
             {
                 var obj = ClassWithConstructor_SimpleAndComplexParameters.GetInstance();
                 JsonSerializer.Serialize(obj, options);
             };
 
-            const int ThreadCount = 8;
-            const int ConcurrentTestsCount = 4;
-            Task[] tasks = new Task[ThreadCount * ConcurrentTestsCount];
-
-            for (int i = 0; i < tasks.Length; i += ConcurrentTestsCount)
+            void RunTest(Type type)
             {
-                // Create race condition to populate the sorted property cache with different json ordering.
-                tasks[i + 0] = Task.Run(() => DeserializeObjectMinimal());
-                tasks[i + 1] = Task.Run(() => DeserializeObjectFlipped());
-                tasks[i + 2] = Task.Run(() => DeserializeObjectNormal());
+                // Use local options to avoid obtaining already cached metadata from the default options.
+                var options = new JsonSerializerOptions();
 
-                // Ensure no exceptions on serialization
-                tasks[i + 3] = Task.Run(() => SerializeObject());
-            };
+                const int ThreadCount = 8;
+                const int ConcurrentTestsCount = 4;
+                Task[] tasks = new Task[ThreadCount * ConcurrentTestsCount];
+
+                for (int i = 0; i < tasks.Length; i += ConcurrentTestsCount)
+                {
+                    // Create race condition to populate the sorted property cache with different json ordering.
+                    tasks[i + 0] = Task.Run(() => DeserializeObjectMinimal(type, options));
+                    tasks[i + 1] = Task.Run(() => DeserializeObjectFlipped(type, options));
+                    tasks[i + 2] = Task.Run(() => DeserializeObjectNormal(type, options));
+
+                    // Ensure no exceptions on serialization
+                    tasks[i + 3] = Task.Run(() => SerializeObject(type, options));
+                };
+
+                Task.WaitAll(tasks);
+            }
 
-            Task.WaitAll(tasks);
+            RunTest(typeof(ClassWithConstructor_SimpleAndComplexParameters));
+            RunTest(typeof(Person_Class));
+            RunTest(typeof(Parameterized_Class_With_ComplexTuple));
         }
 
         [Fact]
diff --git a/src/libraries/System.Text.Json/tests/Serialization/ConstructorTests.ParameterMatching.cs b/src/libraries/System.Text.Json/tests/Serialization/ConstructorTests.ParameterMatching.cs
@@ -8,14 +8,14 @@
 
 namespace System.Text.Json.Serialization.Tests
 {
-    public class ConstructorTests_StringTValue : ConstructorTests
+    public class ConstructorTests_String : ConstructorTests
     {
-        public ConstructorTests_StringTValue() : base(DeserializationWrapper.StringTValueSerializer) { }
+        public ConstructorTests_String() : base(DeserializationWrapper.StringDeserializer) { }
     }
 
-    public class ConstructorTests_StreamTValue : ConstructorTests
+    public class ConstructorTests_Stream : ConstructorTests
     {
-        public ConstructorTests_StreamTValue() : base(DeserializationWrapper.StreamTValueSerializer) { }
+        public ConstructorTests_Stream() : base(DeserializationWrapper.StreamDeserializer) { }
     }
 
     public abstract partial class ConstructorTests
@@ -301,7 +301,6 @@ public void Null_AsArgument_To_ParameterThat_CanNotBeNull()
             Assert.Throws<JsonException>(() => Serializer.Deserialize<ClassWrapper_For_Int_Point_3D_String>(@"{""MyPoint3DStruct"":null,""MyString"":""1""}"));
         }
 
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/33928")]
         [Fact]
         public void OtherPropertiesAreSet()
         {
diff --git a/src/libraries/System.Text.Json/tests/Serialization/DeserializationWrapper.cs b/src/libraries/System.Text.Json/tests/Serialization/DeserializationWrapper.cs
@@ -14,20 +14,27 @@ public abstract class DeserializationWrapper
     {
         private static readonly JsonSerializerOptions _optionsWithSmallBuffer = new JsonSerializerOptions { DefaultBufferSize = 1 };
 
-        public static DeserializationWrapper StringTValueSerializer => new StringTValueSerializerWrapper();
-        public static DeserializationWrapper StreamTValueSerializer => new StreamTValueSerializerWrapper();
+        public static DeserializationWrapper StringDeserializer => new StringDeserializerWrapper();
+        public static DeserializationWrapper StreamDeserializer => new StreamDeserializerWrapper();
 
         protected internal abstract T Deserialize<T>(string json, JsonSerializerOptions options = null);
 
-        private class StringTValueSerializerWrapper : DeserializationWrapper
+        protected internal abstract object Deserialize(string json, Type type, JsonSerializerOptions options = null);
+
+        private class StringDeserializerWrapper : DeserializationWrapper
         {
             protected internal override T Deserialize<T>(string json, JsonSerializerOptions options = null)
             {
                 return JsonSerializer.Deserialize<T>(json, options);
             }
+
+            protected internal override object Deserialize(string json, Type type, JsonSerializerOptions options = null)
+            {
+                return JsonSerializer.Deserialize(json, type, options);
+            }
         }
 
-        private class StreamTValueSerializerWrapper : DeserializationWrapper
+        private class StreamDeserializerWrapper : DeserializationWrapper
         {
             protected internal override T Deserialize<T>(string json, JsonSerializerOptions options = null)
             {
@@ -44,6 +51,22 @@ protected internal override T Deserialize<T>(string json, JsonSerializerOptions
                     }
                 }).GetAwaiter().GetResult();
             }
+
+            protected internal override object Deserialize(string json, Type type, JsonSerializerOptions options = null)
+            {
+                if (options == null)
+                {
+                    options = _optionsWithSmallBuffer;
+                }
+
+                return Task.Run(async () =>
+                {
+                    using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))
+                    {
+                        return await JsonSerializer.DeserializeAsync(stream, type, options);
+                    }
+                }).GetAwaiter().GetResult();
+            }
         }
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/Serialization/TestClasses.Constructor.cs b/src/libraries/System.Text.Json/tests/Serialization/TestClasses.Constructor.cs

Original file line number	Diff line number	Diff line change
`@@ -12,45 +12,47 @@ namespace System.Text.Json.Serialization.Converters`
`12`	`12`	`/// </summary>`
`13`	`13`	`internal sealed class LargeObjectWithParameterizedConstructorConverter<T> : ObjectWithParameterizedConstructorConverter<T> where T : notnull`
`14`	`14`	`{`
`15`		`- private JsonClassInfo.ParameterizedConstructorDelegate<T>? _createObject;`
`16`		`-`
`17`		`- internal override void CreateConstructorDelegate(JsonSerializerOptions options)`
`18`		`- {`
`19`		`- _createObject = options.MemberAccessorStrategy.CreateParameterizedConstructor<T>(ConstructorInfo)!;`
`20`		`- }`
`21`		`-`
`22`	`15`	`protected override bool ReadAndCacheConstructorArgument(ref ReadStack state, ref Utf8JsonReader reader, JsonParameterInfo jsonParameterInfo)`
`23`	`16`	`{`
`24`	`17`	`bool success = jsonParameterInfo.ReadJson(ref state, ref reader, out object? arg0);`
`25`	`18`
`26`	`19`	`if (success)`
`27`	`20`	`{`
`28`		`- ((object[])state.Current.CtorArgumentState!.Arguments!)[jsonParameterInfo.Position] = arg0!;`
	`21`	`+ ((object[])state.Current.CtorArgumentState!.Arguments)[jsonParameterInfo.Position] = arg0!;`
`29`	`22`	`}`
`30`	`23`
`31`	`24`	`return success;`
`32`	`25`	`}`
`33`	`26`
`34`	`27`	`protected override object CreateObject(ref ReadStackFrame frame)`
`35`	`28`	`{`
`36`		`- object[] arguments = (object[])frame.CtorArgumentState!.Arguments!;`
	`29`	`+ object[] arguments = (object[])frame.CtorArgumentState!.Arguments;`
	`30`	`+`
	`31`	`+ var createObject = (JsonClassInfo.ParameterizedConstructorDelegate<T>?)frame.JsonClassInfo.CreateObjectWithParameterizedCtor;`
`37`	`32`
`38`		`- if (_createObject == null)`
	`33`	`+ if (createObject == null)`
`39`	`34`	`{`
`40`	`35`	`// This means this constructor has more than 64 parameters.`
`41`		`- ThrowHelper.ThrowNotSupportedException_ConstructorMaxOf64Parameters(ConstructorInfo, TypeToConvert);`
	`36`	`+ ThrowHelper.ThrowNotSupportedException_ConstructorMaxOf64Parameters(ConstructorInfo!, TypeToConvert);`
`42`	`37`	`}`
`43`	`38`
`44`		`- object obj = _createObject(arguments)!;`
	`39`	`+ object obj = createObject(arguments);`
`45`	`40`
`46`	`41`	`ArrayPool<object>.Shared.Return(arguments, clearArray: true);`
`47`	`42`	`return obj;`
`48`	`43`	`}`
`49`	`44`
`50`	`45`	`protected override void InitializeConstructorArgumentCaches(ref ReadStack state, JsonSerializerOptions options)`
`51`	`46`	`{`
`52`		`- object[] arguments = ArrayPool<object>.Shared.Rent(state.Current.JsonClassInfo.ParameterCount);`
`53`		`- foreach (JsonParameterInfo jsonParameterInfo in state.Current.JsonClassInfo.ParameterCache!.Values)`
	`47`	`+ JsonClassInfo classInfo = state.Current.JsonClassInfo;`
	`48`	`+`
	`49`	`+ if (classInfo.CreateObjectWithParameterizedCtor == null)`
	`50`	`+ {`
	`51`	`+ classInfo.CreateObjectWithParameterizedCtor = options.MemberAccessorStrategy.CreateParameterizedConstructor<T>(ConstructorInfo!);`
	`52`	`+ }`
	`53`	`+`
	`54`	`+ object[] arguments = ArrayPool<object>.Shared.Rent(classInfo.ParameterCount);`
	`55`	`+ foreach (JsonParameterInfo jsonParameterInfo in classInfo.ParameterCache!.Values)`
`54`	`56`	`{`
`55`	`57`	`if (jsonParameterInfo.ShouldDeserialize)`
`56`	`58`	`{`
Original file line number	Diff line number	Diff line change
`@@ -429,7 +429,7 @@ private void BeginRead(ref ReadStack state, ref Utf8JsonReader reader, JsonSeria`
`429`	`429`
`430`	`430`	`if (state.Current.JsonClassInfo.ParameterCount != state.Current.JsonClassInfo.ParameterCache!.Count)`
`431`	`431`	`{`
`432`		`- ThrowHelper.ThrowInvalidOperationException_ConstructorParameterIncompleteBinding(ConstructorInfo, TypeToConvert);`
	`432`	`+ ThrowHelper.ThrowInvalidOperationException_ConstructorParameterIncompleteBinding(ConstructorInfo!, TypeToConvert);`
`433`	`433`	`}`
`434`	`434`
`435`	`435`	`// Set current JsonPropertyInfo to null to avoid conflicts on push.`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@ internal sealed partial class JsonClassInfo`
`20`	`20`
`21`	`21`	`public ConstructorDelegate? CreateObject { get; private set; }`
`22`	`22`
	`23`	`+ public object? CreateObjectWithParameterizedCtor { get; set; }`
	`24`	`+`
`23`	`25`	`public ClassType ClassType { get; private set; }`
`24`	`26`
`25`	`27`	`public JsonPropertyInfo? DataExtensionProperty { get; private set; }`
`@@ -159,8 +161,7 @@ public JsonClassInfo(Type type, JsonSerializerOptions options)`
`159`	`161`
`160`	`162`	`if (converter.ConstructorIsParameterized)`
`161`	`163`	`{`
`162`		`- converter.CreateConstructorDelegate(options);`
`163`		`- InitializeConstructorParameters(converter.ConstructorInfo);`
	`164`	`+ InitializeConstructorParameters(converter.ConstructorInfo!);`
`164`	`165`	`}`
`165`	`166`	`}`
`166`	`167`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -78,8 +78,6 @@ internal bool ShouldFlush(Utf8JsonWriter writer, ref WriteStack state)`
`78`	`78`	`// Whether a type (ClassType.Object) is deserialized using a parameterized constructor.`
`79`	`79`	`internal virtual bool ConstructorIsParameterized => false;`
`80`	`80`
`81`		`- internal ConstructorInfo ConstructorInfo { get; set; } = null!;`
`82`		`-`
`83`		`- internal virtual void CreateConstructorDelegate(JsonSerializerOptions options) { }`
	`81`	`+ internal ConstructorInfo? ConstructorInfo { get; set; }`
`84`	`82`	`}`
`85`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,14 @@`
`8`	`8`
`9`	`9`	`namespace System.Text.Json.Serialization.Tests`
`10`	`10`	`{`
`11`		`- public class ConstructorTests_StringTValue : ConstructorTests`
	`11`	`+ public class ConstructorTests_String : ConstructorTests`
`12`	`12`	`{`
`13`		`- public ConstructorTests_StringTValue() : base(DeserializationWrapper.StringTValueSerializer) { }`
	`13`	`+ public ConstructorTests_String() : base(DeserializationWrapper.StringDeserializer) { }`
`14`	`14`	`}`
`15`	`15`
`16`		`- public class ConstructorTests_StreamTValue : ConstructorTests`
	`16`	`+ public class ConstructorTests_Stream : ConstructorTests`
`17`	`17`	`{`
`18`		`- public ConstructorTests_StreamTValue() : base(DeserializationWrapper.StreamTValueSerializer) { }`
	`18`	`+ public ConstructorTests_Stream() : base(DeserializationWrapper.StreamDeserializer) { }`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public abstract partial class ConstructorTests`
`@@ -301,7 +301,6 @@ public void Null_AsArgument_To_ParameterThat_CanNotBeNull()`
`301`	`301`	`Assert.Throws<JsonException>(() => Serializer.Deserialize<ClassWrapper_For_Int_Point_3D_String>(@"{""MyPoint3DStruct"":null,""MyString"":""1""}"));`
`302`	`302`	`}`
`303`	`303`
`304`		`- [ActiveIssue("https://github.com/dotnet/runtime/issues/33928")]`
`305`	`304`	`[Fact]`
`306`	`305`	`public void OtherPropertiesAreSet()`
`307`	`306`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,20 +14,27 @@ public abstract class DeserializationWrapper`
`14`	`14`	`{`
`15`	`15`	`private static readonly JsonSerializerOptions _optionsWithSmallBuffer = new JsonSerializerOptions { DefaultBufferSize = 1 };`
`16`	`16`
`17`		`- public static DeserializationWrapper StringTValueSerializer => new StringTValueSerializerWrapper();`
`18`		`- public static DeserializationWrapper StreamTValueSerializer => new StreamTValueSerializerWrapper();`
	`17`	`+ public static DeserializationWrapper StringDeserializer => new StringDeserializerWrapper();`
	`18`	`+ public static DeserializationWrapper StreamDeserializer => new StreamDeserializerWrapper();`
`19`	`19`
`20`	`20`	`protected internal abstract T Deserialize<T>(string json, JsonSerializerOptions options = null);`
`21`	`21`
`22`		`- private class StringTValueSerializerWrapper : DeserializationWrapper`
	`22`	`+ protected internal abstract object Deserialize(string json, Type type, JsonSerializerOptions options = null);`
	`23`	`+`
	`24`	`+ private class StringDeserializerWrapper : DeserializationWrapper`
`23`	`25`	`{`
`24`	`26`	`protected internal override T Deserialize<T>(string json, JsonSerializerOptions options = null)`
`25`	`27`	`{`
`26`	`28`	`return JsonSerializer.Deserialize<T>(json, options);`
`27`	`29`	`}`
	`30`	`+`
	`31`	`+ protected internal override object Deserialize(string json, Type type, JsonSerializerOptions options = null)`
	`32`	`+ {`
	`33`	`+ return JsonSerializer.Deserialize(json, type, options);`
	`34`	`+ }`
`28`	`35`	`}`
`29`	`36`
`30`		`- private class StreamTValueSerializerWrapper : DeserializationWrapper`
	`37`	`+ private class StreamDeserializerWrapper : DeserializationWrapper`
`31`	`38`	`{`
`32`	`39`	`protected internal override T Deserialize<T>(string json, JsonSerializerOptions options = null)`
`33`	`40`	`{`
`@@ -44,6 +51,22 @@ protected internal override T Deserialize<T>(string json, JsonSerializerOptions`
`44`	`51`	`}`
`45`	`52`	`}).GetAwaiter().GetResult();`
`46`	`53`	`}`
	`54`	`+`
	`55`	`+ protected internal override object Deserialize(string json, Type type, JsonSerializerOptions options = null)`
	`56`	`+ {`
	`57`	`+ if (options == null)`
	`58`	`+ {`
	`59`	`+ options = _optionsWithSmallBuffer;`
	`60`	`+ }`
	`61`	`+`
	`62`	`+ return Task.Run(async () =>`
	`63`	`+ {`
	`64`	`+ using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))`
	`65`	`+ {`
	`66`	`+ return await JsonSerializer.DeserializeAsync(stream, type, options);`
	`67`	`+ }`
	`68`	`+ }).GetAwaiter().GetResult();`
	`69`	`+ }`
`47`	`70`	`}`
`48`	`71`	`}`
`49`	`72`	`}`