Fix performance issue when deserializing large payloads in JsonObject extension data.

Bug fix to address performance issues when deserializing large payloads in `JsonObject` extension data.

Mitigates performance issues by optimizing the deserialization process for large `JsonObject` extension data properties.
- Added `LargeJsonObjectExtensionDataSerializationState` class to temporarily store properties in a dictionary for efficient updates.
- Modified `JsonObjectConverter` to use the new state class for large objects.
- Updated `ObjectDefaultConverter` and `ObjectWithParameterizedConstructorConverter` to complete deserialization using the new state class.
- Added tests in `JsonObjectTests` to validate performance improvements with large payloads.

Author: Eirik George Tsarpalis

src/libraries/Microsoft.Extensions.DependencyModel/src/Microsoft.Extensions.DependencyModel.csproj

@@ -2,6 +2,8 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <ServicingVersion>1</ServicingVersion>
     <PackageDescription>Abstractions for reading `.deps` files.
 
 Commonly Used Types:

src/libraries/System.Text.Json/src/System.Text.Json.csproj

@@ -9,8 +9,8 @@
     <Nullable>enable</Nullable>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <IsPackable>true</IsPackable>
-    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-    <ServicingVersion>9</ServicingVersion>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <ServicingVersion>10</ServicingVersion>
     <PackageDescription>Provides high-performance and low-allocating types that serialize objects to JavaScript Object Notation (JSON) text and deserialize JSON text to objects, with UTF-8 support built-in. Also provides types to read and write JSON text encoded as UTF-8, and to create an in-memory document object model (DOM), that is read-only, for random access of the JSON elements within a structured view of the data.
 
 Commonly Used Types:
@@ -106,6 +106,7 @@ System.Text.Json.Utf8JsonReader</PackageDescription>
     <Compile Include="System\Text\Json\Serialization\Converters\Collection\ImmutableEnumerableOfTConverterWithReflection.cs" />
     <Compile Include="System\Text\Json\Serialization\Converters\Collection\StackOrQueueConverterWithReflection.cs" />
     <Compile Include="System\Text\Json\Serialization\Converters\JsonMetadataServicesConverter.cs" />
+    <Compile Include="System\Text\Json\Serialization\Converters\Node\LargeJsonObjectExtensionDataSerializationState.cs" />
     <Compile Include="System\Text\Json\Serialization\Converters\Object\ObjectWithParameterizedConstructorConverter.Large.Reflection.cs" />
     <Compile Include="System\Text\Json\Serialization\IgnoreReferenceResolver.cs" />
     <Compile Include="System\Text\Json\Serialization\IJsonOnDeserialized.cs" />

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Node/JsonObjectConverter.cs

@@ -26,10 +26,18 @@ internal override void ReadElementAndSetProperty(
             Debug.Assert(obj is JsonObject);
             JsonObject jObject = (JsonObject)obj;
 
-            Debug.Assert(value == null || value is JsonNode);
-            JsonNode? jNodeValue = (JsonNode?)value;
+            if (jObject.Count < LargeJsonObjectExtensionDataSerializationState.LargeObjectThreshold)
+            {
+                jObject[propertyName] = value;
+            }
+            else
+            {
+                LargeJsonObjectExtensionDataSerializationState deserializationState =
+                    state.Current.LargeJsonObjectExtensionDataSerializationState ??= new(jObject);
 
-            jObject[propertyName] = jNodeValue;
+                Debug.Assert(ReferenceEquals(deserializationState.Destination, jObject));
+                deserializationState.AddProperty(propertyName, value);
+            }
         }
 
         public override void Write(Utf8JsonWriter writer, JsonObject value, JsonSerializerOptions options)

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Node/LargeJsonObjectExtensionDataSerializationState.cs

@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Text.Json.Nodes;
+
+namespace System.Text.Json.Serialization.Converters
+{
+    /// <summary>
+    /// Implements a mitigation for deserializing large JsonObject extension data properties.
+    /// Extension data properties use replace semantics when duplicate keys are encountered,
+    /// which is an O(n) operation for JsonObject resulting in O(n^2) total deserialization time.
+    /// This class mitigates the performance issue by storing the deserialized properties in a
+    /// temporary dictionary (which has O(1) updates) and copies them to the destination object
+    /// at the end of deserialization.
+    /// </summary>
+    internal sealed class LargeJsonObjectExtensionDataSerializationState
+    {
+        public const int LargeObjectThreshold = 25;
+        private readonly Dictionary<string, JsonNode?> _tempDictionary;
+        public JsonObject Destination { get; }
+
+        public LargeJsonObjectExtensionDataSerializationState(JsonObject destination)
+        {
+            StringComparer comparer = destination.Options?.PropertyNameCaseInsensitive ?? false
+                ? StringComparer.OrdinalIgnoreCase
+                : StringComparer.Ordinal;
+
+            Destination = destination;
+            _tempDictionary = new(comparer);
+        }
+
+        /// <summary>
+        /// Stores a deserialized property to the temporary dictionary, using replace semantics.
+        /// </summary>
+        public void AddProperty(string key, JsonNode? value)
+        {
+            _tempDictionary[key] = value;
+        }
+
+        /// <summary>
+        /// Copies the properties from the temporary dictionary to the destination JsonObject.
+        /// </summary>
+        public void Complete()
+        {
+            // Because we're only appending values to _tempDictionary, this should preserve JSON ordering.
+            foreach (KeyValuePair<string, JsonNode?> kvp in _tempDictionary)
+            {
+                Destination[kvp.Key] = kvp.Value;
+            }
+        }
+    }
+}

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs

@@ -243,6 +243,9 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
                 jsonTypeInfo.UpdateSortedPropertyCache(ref state.Current);
             }
 
+            // Complete any JsonObject extension data deserializations.
+            state.Current.LargeJsonObjectExtensionDataSerializationState?.Complete();
+
             return true;
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs

@@ -165,6 +165,9 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo
                 state.Current.JsonTypeInfo.UpdateSortedParameterCache(ref state.Current);
             }
 
+            // Complete any JsonObject extension data deserializations.
+            state.Current.LargeJsonObjectExtensionDataSerializationState?.Complete();
+
             return true;
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/ReadStackFrame.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Converters;
 using System.Text.Json.Serialization.Metadata;
 
 namespace System.Text.Json
@@ -34,6 +35,7 @@ internal struct ReadStackFrame
         public JsonTypeInfo JsonTypeInfo;
         public StackFrameObjectState ObjectState; // State tracking the current object.
 
+        public LargeJsonObjectExtensionDataSerializationState? LargeJsonObjectExtensionDataSerializationState;
         // Validate EndObject token on array with preserve semantics.
         public bool ValidateEndTokenOnArray;
 

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonNode/JsonObjectTests.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Tests;
 using Xunit;
 
@@ -920,5 +921,33 @@ public static void ChangeCollectionWhileEnumeratingFails(JsonObject jObject, int
             });
             Assert.Equal(1, index);
         }
+
+        [Theory]
+        [InlineData(10_000)]
+        [InlineData(50_000)]
+        [InlineData(100_000)]
+        public static void JsonObject_ExtensionData_ManyDuplicatePayloads(int size)
+        {
+            // Generate the payload
+            StringBuilder builder = new StringBuilder();
+            builder.Append("{");
+            for (int i = 0; i < size; i++)
+            {
+                builder.Append($"\"{i}\": 0,");
+                builder.Append($"\"{i}\": 0,");
+            }
+            builder.Length--; // strip trailing comma
+            builder.Append("}");
+
+            string jsonPayload = builder.ToString();
+            ClassWithObjectExtensionData result = JsonSerializer.Deserialize<ClassWithObjectExtensionData>(jsonPayload);
+            Assert.Equal(size, result.ExtensionData.Count);
+        }
+
+        class ClassWithObjectExtensionData
+        {
+            [JsonExtensionData]
+            public JsonObject ExtensionData { get; set; }
+        }
     }
 }