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 in `System.Text.Json.Serialization.Converters` to handle large payloads efficiently.
- Updated `JsonObjectConverter` to use the new state class for large objects.
- Modified `ObjectDefaultConverter`, `ObjectWithParameterizedConstructorConverter`, and `ReadStackFrame` to complete deserialization using the new state class.
- Added tests in `JsonObjectTests` to validate the performance improvements with large payloads.

Author: Eirik George Tsarpalis

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

@@ -3,8 +3,8 @@
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
     <IsPackable>true</IsPackable>
-    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-    <ServicingVersion>1</ServicingVersion>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <ServicingVersion>2</ServicingVersion>
     <PackageDescription>Provides abstractions for reading `.deps` files. When a .NET application is compiled, the SDK generates a JSON manifest file (`&lt;ApplicationName&gt;.deps.json`) that contains information about application dependencies. You can use `Microsoft.Extensions.DependencyModel` to read information from this manifest at run time. This is useful when you want to dynamically compile code (for example, using Roslyn Emit API) referencing the same dependencies as your main application.
 
 By default, the dependency manifest contains information about the application's target framework and runtime dependencies. Set the PreserveCompilationContext project property to `true` to additionally include information about reference assemblies used during compilation.</PackageDescription>

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

@@ -8,8 +8,8 @@
     <NoWarn>CS8969</NoWarn>
     <IncludeInternalObsoleteAttribute>true</IncludeInternalObsoleteAttribute>
     <IsPackable>true</IsPackable>
-    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-    <ServicingVersion>4</ServicingVersion>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <ServicingVersion>5</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.
 
 The System.Text.Json library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.</PackageDescription>
@@ -122,6 +122,7 @@ The System.Text.Json library is built-in as part of the shared framework in .NET
     <Compile Include="System\Text\Json\Serialization\Converters\Collection\MemoryConverterFactory.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\Converters\Collection\MemoryConverter.cs" />
     <Compile Include="System\Text\Json\Serialization\Converters\Value\ReadOnlyMemoryByteConverter.cs" />

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

@@ -27,10 +27,18 @@ internal override void ReadElementAndSetProperty(
             Debug.Assert(obj is JsonObject);
             JsonObject jObject = (JsonObject)obj;
 
-            Debug.Assert(value == null || value is JsonNode);
-            JsonNode? jNodeValue = 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

@@ -254,6 +254,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;
         }
 
@@ -299,6 +302,9 @@ internal static void PopulatePropertiesFastPath(object obj, JsonTypeInfo jsonTyp
             {
                 jsonTypeInfo.UpdateSortedPropertyCache(ref state.Current);
             }
+
+            // Complete any JsonObject extension data deserializations.
+            state.Current.LargeJsonObjectExtensionDataSerializationState?.Complete();
         }
 
         internal sealed override bool OnTryWrite(

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

@@ -267,6 +267,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

@@ -7,6 +7,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Converters;
 using System.Text.Json.Serialization.Metadata;
 
 namespace System.Text.Json
@@ -40,6 +41,8 @@ internal struct ReadStackFrame
         public JsonTypeInfo JsonTypeInfo;
         public StackFrameObjectState ObjectState; // State tracking the current object.
 
+        public LargeJsonObjectExtensionDataSerializationState? LargeJsonObjectExtensionDataSerializationState;
+
         // Current object can contain metadata
         public bool CanContainMetadata;
         public MetadataPropertyName LatestMetadataPropertyName;

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

@@ -5,7 +5,9 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Tests;
+using System.Text.Json.Tests;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -1189,5 +1191,33 @@ public static void ReplaceWith()
             Assert.Null(jValue.Parent);
             Assert.Equal("{\"value\":5}", jObject.ToJsonString());
         }
+
+        [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; }
+        }
     }
 }