STJ: Support serialization callbacks for collection and dictionary types (#104120)

manandre · eiriktsarpalis · web-flow · commit 856a0a6f5e99 · 2024-07-12T20:02:19.000+01:00
* STJ: Support serialization callbacks for collection and dictionary types

* Fix tests

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonCollectionConverter.cs

Co-authored-by: Eirik Tsarpalis &lt;eirik.tsarpalis@gmail.com&gt;

* Update src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonDictionaryConverter.cs

Co-authored-by: Eirik Tsarpalis &lt;eirik.tsarpalis@gmail.com&gt;

* Reverse Kind logic to be more future proof

* Trigger callbacks before writing any JSON or metadata content

* Add JsonTypeInfo tests

* Call OnSerializing before any writing operation

* Keep result as variable name for partial operations

* Prevent setting OnDeserialize callback on immutable types

* Avoid using reflection when possible

* Set IsImmutableType for all converters overriding ConvertCollection

* Rename to IsImmutableCollectionType

* Remove extra empty lines

* Rename exception message

* Rename immutable -&gt; convertible and fix issue around callback use for struct types

---------

Co-authored-by: Eirik Tsarpalis &lt;eirik.tsarpalis@gmail.com&gt;
diff --git a/src/libraries/System.Text.Json/src/Resources/Strings.resx b/src/libraries/System.Text.Json/src/Resources/Strings.resx
@@ -674,6 +674,9 @@
   <data name="InvalidJsonTypeInfoOperationForKind" xml:space="preserve">
     <value>Invalid JsonTypeInfo operation for JsonTypeInfoKind '{0}'.</value>
   </data>
+  <data name="OnDeserializingCallbacksNotSupported" xml:space="preserve">
+    <value>The type '{0}' does not support setting OnDeserializing callbacks.</value>
+  </data>
   <data name="CreateObjectConverterNotCompatible" xml:space="preserve">
     <value>The converter for type '{0}' does not support setting 'CreateObject' delegates.</value>
   </data>
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ArrayConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ArrayConverter.cs
@@ -24,6 +24,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<TElement>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             List<TElement> list = (List<TElement>)state.Current.ReturnValue!;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ImmutableDictionaryOfTKeyTValueConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ImmutableDictionaryOfTKeyTValueConverter.cs
@@ -25,6 +25,7 @@ protected sealed override void CreateCollection(ref Utf8JsonReader reader, scope
             state.Current.ReturnValue = new Dictionary<TKey, TValue>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected sealed override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             Func<IEnumerable<KeyValuePair<TKey, TValue>>, TDictionary>? creator =
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ImmutableEnumerableOfTConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ImmutableEnumerableOfTConverter.cs
@@ -24,6 +24,7 @@ protected sealed override void CreateCollection(ref Utf8JsonReader reader, scope
             state.Current.ReturnValue = new List<TElement>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected sealed override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             JsonTypeInfo typeInfo = state.Current.JsonTypeInfo;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonCollectionConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonCollectionConverter.cs
@@ -41,6 +41,10 @@ protected virtual void CreateCollection(ref Utf8JsonReader reader, scoped ref Re
             Debug.Assert(state.Current.ReturnValue is TCollection);
         }
 
+        /// <summary>
+        /// When overridden, converts the temporary collection held in state.Current.ReturnValue to the final collection.
+        /// The <see cref="JsonConverter.IsConvertibleCollection"/> property must also be set to <see langword="true"/>.
+        /// </summary>
         protected virtual void ConvertCollection(ref ReadStack state, JsonSerializerOptions options) { }
 
         protected static JsonConverter<TElement> GetElementConverter(JsonTypeInfo elementTypeInfo)
@@ -61,7 +65,8 @@ internal override bool OnTryRead(
             scoped ref ReadStack state,
             [MaybeNullWhen(false)] out TCollection value)
         {
-            JsonTypeInfo elementTypeInfo = state.Current.JsonTypeInfo.ElementTypeInfo!;
+            JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
+            JsonTypeInfo elementTypeInfo = jsonTypeInfo.ElementTypeInfo!;
 
             if (!state.SupportContinuation && !state.Current.CanContainMetadata)
             {
@@ -74,6 +79,8 @@ internal override bool OnTryRead(
 
                 CreateCollection(ref reader, ref state, options);
 
+                jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);
+
                 state.Current.JsonPropertyInfo = elementTypeInfo.PropertyInfoForTypeInfo;
                 JsonConverter<TElement> elementConverter = GetElementConverter(elementTypeInfo);
                 if (elementConverter.CanUseDirectReadOrWrite && state.Current.NumberHandling == null)
@@ -112,8 +119,6 @@ internal override bool OnTryRead(
             else
             {
                 // Slower path that supports continuation and reading metadata.
-                JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
-
                 if (state.Current.ObjectState == StackFrameObjectState.None)
                 {
                     if (reader.TokenType == JsonTokenType.StartArray)
@@ -183,6 +188,8 @@ internal override bool OnTryRead(
                         state.ReferenceId = null;
                     }
 
+                    jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);
+
                     state.Current.ObjectState = StackFrameObjectState.CreatedObject;
                 }
 
@@ -274,7 +281,10 @@ internal override bool OnTryRead(
             }
 
             ConvertCollection(ref state, options);
-            value = (TCollection)state.Current.ReturnValue!;
+            object returnValue = state.Current.ReturnValue!;
+            jsonTypeInfo.OnDeserialized?.Invoke(returnValue);
+            value = (TCollection)returnValue;
+
             return true;
         }
 
@@ -293,18 +303,22 @@ internal override bool OnTryWrite(
             }
             else
             {
+                JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
+
                 if (!state.Current.ProcessedStartToken)
                 {
                     state.Current.ProcessedStartToken = true;
 
+                    jsonTypeInfo.OnSerializing?.Invoke(value);
+
                     if (state.CurrentContainsMetadata && CanHaveMetadata)
                     {
                         state.Current.MetadataPropertyName = JsonSerializer.WriteMetadataForCollection(this, ref state, writer);
                     }
 
                     // Writing the start of the array must happen after any metadata
                     writer.WriteStartArray();
-                    state.Current.JsonPropertyInfo = state.Current.JsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;
+                    state.Current.JsonPropertyInfo = jsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;
                 }
 
                 success = OnWriteResume(writer, value, options, ref state);
@@ -321,6 +335,8 @@ internal override bool OnTryWrite(
                             writer.WriteEndObject();
                         }
                     }
+
+                    jsonTypeInfo.OnSerialized?.Invoke(value);
                 }
             }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonDictionaryConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/JsonDictionaryConverter.cs
@@ -76,8 +76,9 @@ internal sealed override bool OnTryRead(
             scoped ref ReadStack state,
             [MaybeNullWhen(false)] out TDictionary value)
         {
-            JsonTypeInfo keyTypeInfo = state.Current.JsonTypeInfo.KeyTypeInfo!;
-            JsonTypeInfo elementTypeInfo = state.Current.JsonTypeInfo.ElementTypeInfo!;
+            JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
+            JsonTypeInfo keyTypeInfo = jsonTypeInfo.KeyTypeInfo!;
+            JsonTypeInfo elementTypeInfo = jsonTypeInfo.ElementTypeInfo!;
 
             if (!state.SupportContinuation && !state.Current.CanContainMetadata)
             {
@@ -90,6 +91,8 @@ internal sealed override bool OnTryRead(
 
                 CreateCollection(ref reader, ref state);
 
+                jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);
+
                 _keyConverter ??= GetConverter<TKey>(keyTypeInfo);
                 _valueConverter ??= GetConverter<TValue>(elementTypeInfo);
 
@@ -149,8 +152,6 @@ internal sealed override bool OnTryRead(
             else
             {
                 // Slower path that supports continuation and reading metadata.
-                JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
-
                 if (state.Current.ObjectState == StackFrameObjectState.None)
                 {
                     if (reader.TokenType != JsonTokenType.StartObject)
@@ -210,6 +211,8 @@ internal sealed override bool OnTryRead(
                         state.ReferenceId = null;
                     }
 
+                    jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);
+
                     state.Current.ObjectState = StackFrameObjectState.CreatedObject;
                 }
 
@@ -302,7 +305,10 @@ internal sealed override bool OnTryRead(
             }
 
             ConvertCollection(ref state, options);
-            value = (TDictionary)state.Current.ReturnValue!;
+            object result = state.Current.ReturnValue!;
+            jsonTypeInfo.OnDeserialized?.Invoke(result);
+            value = (TDictionary)result;
+
             return true;
 
             static TKey ReadDictionaryKey(JsonConverter<TKey> keyConverter, ref Utf8JsonReader reader, scoped ref ReadStack state, JsonSerializerOptions options)
@@ -337,17 +343,22 @@ internal sealed override bool OnTryWrite(
                 return true;
             }
 
+            JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
+
             if (!state.Current.ProcessedStartToken)
             {
                 state.Current.ProcessedStartToken = true;
+
+                jsonTypeInfo.OnSerializing?.Invoke(dictionary);
+
                 writer.WriteStartObject();
 
                 if (state.CurrentContainsMetadata && CanHaveMetadata)
                 {
                     JsonSerializer.WriteMetadataForObject(this, ref state, writer);
                 }
 
-                state.Current.JsonPropertyInfo = state.Current.JsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;
+                state.Current.JsonPropertyInfo = jsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;
             }
 
             bool success = OnWriteResume(writer, dictionary, options, ref state);
@@ -358,6 +369,8 @@ internal sealed override bool OnTryWrite(
                     state.Current.ProcessedEndToken = true;
                     writer.WriteEndObject();
                 }
+
+                jsonTypeInfo.OnSerialized?.Invoke(dictionary);
             }
 
             return success;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/MemoryConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/MemoryConverter.cs
@@ -37,6 +37,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<T>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             Memory<T> memory = ((List<T>)state.Current.ReturnValue!).ToArray().AsMemory();
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ReadOnlyMemoryConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/ReadOnlyMemoryConverter.cs
@@ -37,6 +37,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<T>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             ReadOnlyMemory<T> memory = ((List<T>)state.Current.ReturnValue!).ToArray().AsMemory();
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpListConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpListConverter.cs
@@ -31,6 +31,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<TElement>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             state.Current.ReturnValue = _listConstructor((List<TElement>)state.Current.ReturnValue!);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpMapConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpMapConverter.cs
@@ -34,6 +34,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<Tuple<TKey, TValue>>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             state.Current.ReturnValue = _mapConstructor((List<Tuple<TKey, TValue>>)state.Current.ReturnValue!);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpSetConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpSetConverter.cs
@@ -31,6 +31,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R
             state.Current.ReturnValue = new List<TElement>();
         }
 
+        internal sealed override bool IsConvertibleCollection => true;
         protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)
         {
             state.Current.ReturnValue = _setConstructor((List<TElement>)state.Current.ReturnValue!);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs
@@ -326,15 +326,15 @@ internal sealed override bool OnTryWrite(
 
             if (!state.SupportContinuation)
             {
+                jsonTypeInfo.OnSerializing?.Invoke(obj);
+
                 writer.WriteStartObject();
 
                 if (state.CurrentContainsMetadata && CanHaveMetadata)
                 {
                     JsonSerializer.WriteMetadataForObject(this, ref state, writer);
                 }
 
-                jsonTypeInfo.OnSerializing?.Invoke(obj);
-
                 foreach (JsonPropertyInfo jsonPropertyInfo in jsonTypeInfo.PropertyCache)
                 {
                     if (jsonPropertyInfo.CanSerialize)
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
@@ -179,6 +179,13 @@ internal JsonConverter<TTarget> CreateCastingConverter<TTarget>()
         /// </summary>
         internal bool IsInternalConverterForNumberType { get; init; }
 
+        /// <summary>
+        /// Whether the converter handles collection deserialization by converting from
+        /// an intermediate buffer such as immutable collections, arrays or memory types.
+        /// Used in conjunction with <see cref="JsonCollectionConverter{TCollection, TElement}.ConvertCollection(ref ReadStack, JsonSerializerOptions)"/>.
+        /// </summary>
+        internal virtual bool IsConvertibleCollection => false;
+
         internal static bool ShouldFlush(ref WriteStack state, Utf8JsonWriter writer)
         {
             Debug.Assert(state.FlushThreshold == 0 || (state.PipeWriter is { CanGetUnflushedBytes: true }),
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs
@@ -123,7 +123,7 @@ public Action<object>? OnSerializing
             {
                 VerifyMutable();
 
-                if (Kind != JsonTypeInfoKind.Object)
+                if (Kind is not (JsonTypeInfoKind.Object or JsonTypeInfoKind.Enumerable or JsonTypeInfoKind.Dictionary))
                 {
                     ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoOperationNotPossibleForKind(Kind);
                 }
@@ -153,7 +153,7 @@ public Action<object>? OnSerialized
             {
                 VerifyMutable();
 
-                if (Kind != JsonTypeInfoKind.Object)
+                if (Kind is not (JsonTypeInfoKind.Object or JsonTypeInfoKind.Enumerable or JsonTypeInfoKind.Dictionary))
                 {
                     ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoOperationNotPossibleForKind(Kind);
                 }
@@ -183,11 +183,17 @@ public Action<object>? OnDeserializing
             {
                 VerifyMutable();
 
-                if (Kind != JsonTypeInfoKind.Object)
+                if (Kind is not (JsonTypeInfoKind.Object or JsonTypeInfoKind.Enumerable or JsonTypeInfoKind.Dictionary))
                 {
                     ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoOperationNotPossibleForKind(Kind);
                 }
 
+                if (Converter.IsConvertibleCollection)
+                {
+                    // The values for convertible collections aren't available at the start of deserialization.
+                    ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoOnDeserializingCallbacksNotSupported(Type);
+                }
+
                 _onDeserializing = value;
             }
         }
@@ -213,7 +219,7 @@ public Action<object>? OnDeserialized
             {
                 VerifyMutable();
 
-                if (Kind != JsonTypeInfoKind.Object)
+                if (Kind is not (JsonTypeInfoKind.Object or JsonTypeInfoKind.Enumerable or JsonTypeInfoKind.Dictionary))
                 {
                     ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoOperationNotPossibleForKind(Kind);
                 }
@@ -1256,9 +1262,7 @@ internal void MapInterfaceTypesToCallbacks()
         {
             Debug.Assert(!IsReadOnly);
 
-            // Callbacks currently only supported in object kinds
-            // TODO: extend to collections/dictionaries
-            if (Kind == JsonTypeInfoKind.Object)
+            if (Kind is JsonTypeInfoKind.Object or JsonTypeInfoKind.Enumerable or JsonTypeInfoKind.Dictionary)
             {
                 if (typeof(IJsonOnSerializing).IsAssignableFrom(Type))
                 {
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
@@ -414,6 +414,12 @@ public static void ThrowInvalidOperationException_JsonTypeInfoOperationNotPossib
             throw new InvalidOperationException(SR.Format(SR.InvalidJsonTypeInfoOperationForKind, kind));
         }
 
+        [DoesNotReturn]
+        public static void ThrowInvalidOperationException_JsonTypeInfoOnDeserializingCallbacksNotSupported(Type type)
+        {
+            throw new InvalidOperationException(SR.Format(SR.OnDeserializingCallbacksNotSupported, type));
+        }
+
         [DoesNotReturn]
         public static void ThrowInvalidOperationException_CreateObjectConverterNotCompatible(Type type)
         {
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/MetadataTests/DefaultJsonTypeInfoResolverTests.JsonTypeInfo.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/MetadataTests/DefaultJsonTypeInfoResolverTests.JsonTypeInfo.cs
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OnSerializeTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OnSerializeTests.cs

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R`
`24`	`24`	`state.Current.ReturnValue = new List<TElement>();`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ internal sealed override bool IsConvertibleCollection => true;`
`27`	`28`	`protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`28`	`29`	`{`
`29`	`30`	`List<TElement> list = (List<TElement>)state.Current.ReturnValue!;`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ protected sealed override void CreateCollection(ref Utf8JsonReader reader, scope`
`25`	`25`	`state.Current.ReturnValue = new Dictionary<TKey, TValue>();`
`26`	`26`	`}`
`27`	`27`
	`28`	`+ internal sealed override bool IsConvertibleCollection => true;`
`28`	`29`	`protected sealed override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`29`	`30`	`{`
`30`	`31`	`Func<IEnumerable<KeyValuePair<TKey, TValue>>, TDictionary>? creator =`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ protected sealed override void CreateCollection(ref Utf8JsonReader reader, scope`
`24`	`24`	`state.Current.ReturnValue = new List<TElement>();`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ internal sealed override bool IsConvertibleCollection => true;`
`27`	`28`	`protected sealed override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`28`	`29`	`{`
`29`	`30`	`JsonTypeInfo typeInfo = state.Current.JsonTypeInfo;`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,10 @@ protected virtual void CreateCollection(ref Utf8JsonReader reader, scoped ref Re`
`41`	`41`	`Debug.Assert(state.Current.ReturnValue is TCollection);`
`42`	`42`	`}`
`43`	`43`
	`44`	`+ /// <summary>`
	`45`	`+ /// When overridden, converts the temporary collection held in state.Current.ReturnValue to the final collection.`
	`46`	`+ /// The <see cref="JsonConverter.IsConvertibleCollection"/> property must also be set to <see langword="true"/>.`
	`47`	`+ /// </summary>`
`44`	`48`	`protected virtual void ConvertCollection(ref ReadStack state, JsonSerializerOptions options) { }`
`45`	`49`
`46`	`50`	`protected static JsonConverter<TElement> GetElementConverter(JsonTypeInfo elementTypeInfo)`
`@@ -61,7 +65,8 @@ internal override bool OnTryRead(`
`61`	`65`	`scoped ref ReadStack state,`
`62`	`66`	`[MaybeNullWhen(false)] out TCollection value)`
`63`	`67`	`{`
`64`		`- JsonTypeInfo elementTypeInfo = state.Current.JsonTypeInfo.ElementTypeInfo!;`
	`68`	`+ JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
	`69`	`+ JsonTypeInfo elementTypeInfo = jsonTypeInfo.ElementTypeInfo!;`
`65`	`70`
`66`	`71`	`if (!state.SupportContinuation && !state.Current.CanContainMetadata)`
`67`	`72`	`{`
`@@ -74,6 +79,8 @@ internal override bool OnTryRead(`
`74`	`79`
`75`	`80`	`CreateCollection(ref reader, ref state, options);`
`76`	`81`
	`82`	`+ jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);`
	`83`	`+`
`77`	`84`	`state.Current.JsonPropertyInfo = elementTypeInfo.PropertyInfoForTypeInfo;`
`78`	`85`	`JsonConverter<TElement> elementConverter = GetElementConverter(elementTypeInfo);`
`79`	`86`	`if (elementConverter.CanUseDirectReadOrWrite && state.Current.NumberHandling == null)`
`@@ -112,8 +119,6 @@ internal override bool OnTryRead(`
`112`	`119`	`else`
`113`	`120`	`{`
`114`	`121`	`// Slower path that supports continuation and reading metadata.`
`115`		`- JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
`116`		`-`
`117`	`122`	`if (state.Current.ObjectState == StackFrameObjectState.None)`
`118`	`123`	`{`
`119`	`124`	`if (reader.TokenType == JsonTokenType.StartArray)`
`@@ -183,6 +188,8 @@ internal override bool OnTryRead(`
`183`	`188`	`state.ReferenceId = null;`
`184`	`189`	`}`
`185`	`190`
	`191`	`+ jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);`
	`192`	`+`
`186`	`193`	`state.Current.ObjectState = StackFrameObjectState.CreatedObject;`
`187`	`194`	`}`
`188`	`195`
`@@ -274,7 +281,10 @@ internal override bool OnTryRead(`
`274`	`281`	`}`
`275`	`282`
`276`	`283`	`ConvertCollection(ref state, options);`
`277`		`- value = (TCollection)state.Current.ReturnValue!;`
	`284`	`+ object returnValue = state.Current.ReturnValue!;`
	`285`	`+ jsonTypeInfo.OnDeserialized?.Invoke(returnValue);`
	`286`	`+ value = (TCollection)returnValue;`
	`287`	`+`
`278`	`288`	`return true;`
`279`	`289`	`}`
`280`	`290`
`@@ -293,18 +303,22 @@ internal override bool OnTryWrite(`
`293`	`303`	`}`
`294`	`304`	`else`
`295`	`305`	`{`
	`306`	`+ JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
	`307`	`+`
`296`	`308`	`if (!state.Current.ProcessedStartToken)`
`297`	`309`	`{`
`298`	`310`	`state.Current.ProcessedStartToken = true;`
`299`	`311`
	`312`	`+ jsonTypeInfo.OnSerializing?.Invoke(value);`
	`313`	`+`
`300`	`314`	`if (state.CurrentContainsMetadata && CanHaveMetadata)`
`301`	`315`	`{`
`302`	`316`	`state.Current.MetadataPropertyName = JsonSerializer.WriteMetadataForCollection(this, ref state, writer);`
`303`	`317`	`}`
`304`	`318`
`305`	`319`	`// Writing the start of the array must happen after any metadata`
`306`	`320`	`writer.WriteStartArray();`
`307`		`- state.Current.JsonPropertyInfo = state.Current.JsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;`
	`321`	`+ state.Current.JsonPropertyInfo = jsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;`
`308`	`322`	`}`
`309`	`323`
`310`	`324`	`success = OnWriteResume(writer, value, options, ref state);`
`@@ -321,6 +335,8 @@ internal override bool OnTryWrite(`
`321`	`335`	`writer.WriteEndObject();`
`322`	`336`	`}`
`323`	`337`	`}`
	`338`	`+`
	`339`	`+ jsonTypeInfo.OnSerialized?.Invoke(value);`
`324`	`340`	`}`
`325`	`341`	`}`
`326`	`342`
Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,9 @@ internal sealed override bool OnTryRead(`
`76`	`76`	`scoped ref ReadStack state,`
`77`	`77`	`[MaybeNullWhen(false)] out TDictionary value)`
`78`	`78`	`{`
`79`		`- JsonTypeInfo keyTypeInfo = state.Current.JsonTypeInfo.KeyTypeInfo!;`
`80`		`- JsonTypeInfo elementTypeInfo = state.Current.JsonTypeInfo.ElementTypeInfo!;`
	`79`	`+ JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
	`80`	`+ JsonTypeInfo keyTypeInfo = jsonTypeInfo.KeyTypeInfo!;`
	`81`	`+ JsonTypeInfo elementTypeInfo = jsonTypeInfo.ElementTypeInfo!;`
`81`	`82`
`82`	`83`	`if (!state.SupportContinuation && !state.Current.CanContainMetadata)`
`83`	`84`	`{`
`@@ -90,6 +91,8 @@ internal sealed override bool OnTryRead(`
`90`	`91`
`91`	`92`	`CreateCollection(ref reader, ref state);`
`92`	`93`
	`94`	`+ jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);`
	`95`	`+`
`93`	`96`	`_keyConverter ??= GetConverter<TKey>(keyTypeInfo);`
`94`	`97`	`_valueConverter ??= GetConverter<TValue>(elementTypeInfo);`
`95`	`98`
`@@ -149,8 +152,6 @@ internal sealed override bool OnTryRead(`
`149`	`152`	`else`
`150`	`153`	`{`
`151`	`154`	`// Slower path that supports continuation and reading metadata.`
`152`		`- JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
`153`		`-`
`154`	`155`	`if (state.Current.ObjectState == StackFrameObjectState.None)`
`155`	`156`	`{`
`156`	`157`	`if (reader.TokenType != JsonTokenType.StartObject)`
`@@ -210,6 +211,8 @@ internal sealed override bool OnTryRead(`
`210`	`211`	`state.ReferenceId = null;`
`211`	`212`	`}`
`212`	`213`
	`214`	`+ jsonTypeInfo.OnDeserializing?.Invoke(state.Current.ReturnValue!);`
	`215`	`+`
`213`	`216`	`state.Current.ObjectState = StackFrameObjectState.CreatedObject;`
`214`	`217`	`}`
`215`	`218`
`@@ -302,7 +305,10 @@ internal sealed override bool OnTryRead(`
`302`	`305`	`}`
`303`	`306`
`304`	`307`	`ConvertCollection(ref state, options);`
`305`		`- value = (TDictionary)state.Current.ReturnValue!;`
	`308`	`+ object result = state.Current.ReturnValue!;`
	`309`	`+ jsonTypeInfo.OnDeserialized?.Invoke(result);`
	`310`	`+ value = (TDictionary)result;`
	`311`	`+`
`306`	`312`	`return true;`
`307`	`313`
`308`	`314`	`static TKey ReadDictionaryKey(JsonConverter<TKey> keyConverter, ref Utf8JsonReader reader, scoped ref ReadStack state, JsonSerializerOptions options)`
`@@ -337,17 +343,22 @@ internal sealed override bool OnTryWrite(`
`337`	`343`	`return true;`
`338`	`344`	`}`
`339`	`345`
	`346`	`+ JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;`
	`347`	`+`
`340`	`348`	`if (!state.Current.ProcessedStartToken)`
`341`	`349`	`{`
`342`	`350`	`state.Current.ProcessedStartToken = true;`
	`351`	`+`
	`352`	`+ jsonTypeInfo.OnSerializing?.Invoke(dictionary);`
	`353`	`+`
`343`	`354`	`writer.WriteStartObject();`
`344`	`355`
`345`	`356`	`if (state.CurrentContainsMetadata && CanHaveMetadata)`
`346`	`357`	`{`
`347`	`358`	`JsonSerializer.WriteMetadataForObject(this, ref state, writer);`
`348`	`359`	`}`
`349`	`360`
`350`		`- state.Current.JsonPropertyInfo = state.Current.JsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;`
	`361`	`+ state.Current.JsonPropertyInfo = jsonTypeInfo.ElementTypeInfo!.PropertyInfoForTypeInfo;`
`351`	`362`	`}`
`352`	`363`
`353`	`364`	`bool success = OnWriteResume(writer, dictionary, options, ref state);`
`@@ -358,6 +369,8 @@ internal sealed override bool OnTryWrite(`
`358`	`369`	`state.Current.ProcessedEndToken = true;`
`359`	`370`	`writer.WriteEndObject();`
`360`	`371`	`}`
	`372`	`+`
	`373`	`+ jsonTypeInfo.OnSerialized?.Invoke(dictionary);`
`361`	`374`	`}`
`362`	`375`
`363`	`376`	`return success;`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R`
`37`	`37`	`state.Current.ReturnValue = new List<T>();`
`38`	`38`	`}`
`39`	`39`
	`40`	`+ internal sealed override bool IsConvertibleCollection => true;`
`40`	`41`	`protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`41`	`42`	`{`
`42`	`43`	`Memory<T> memory = ((List<T>)state.Current.ReturnValue!).ToArray().AsMemory();`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R`
`31`	`31`	`state.Current.ReturnValue = new List<TElement>();`
`32`	`32`	`}`
`33`	`33`
	`34`	`+ internal sealed override bool IsConvertibleCollection => true;`
`34`	`35`	`protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`35`	`36`	`{`
`36`	`37`	`state.Current.ReturnValue = _listConstructor((List<TElement>)state.Current.ReturnValue!);`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref R`
`34`	`34`	`state.Current.ReturnValue = new List<Tuple<TKey, TValue>>();`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ internal sealed override bool IsConvertibleCollection => true;`
`37`	`38`	`protected override void ConvertCollection(ref ReadStack state, JsonSerializerOptions options)`
`38`	`39`	`{`
`39`	`40`	`state.Current.ReturnValue = _mapConstructor((List<Tuple<TKey, TValue>>)state.Current.ReturnValue!);`