Fix JsonSerializer.Serialize producing invalid JSON for [JsonExtensionData] with JsonObject (#122838)

Copilot · stephentoub · eiriktsarpalis · web-flow · commit 34c3feeb7200 · 2026-01-13T14:06:07.000+02:00
# Description `JsonSerializer.Serialize` was producing invalid JSON when serializing objects with `[JsonExtensionData]` properties of type `JsonObject`. The output was missing the property name for extension data entries: ```csharp var mix = new Mix { Id = 1, Extra = new JsonObject { ["nested"] = true } }; JsonSerializer.Serialize(mix); // Before: {"Id":1,{"nested":true}} ← invalid JSON // After: {"Id":1,"nested":true} ← correct ``` **Root cause**: `TryWriteDataExtensionProperty` in `JsonConverterOfT.cs` called `TryWrite` for `JsonObject`, which writes the full object including braces. Extension data should write only the contents (key-value pairs) without wrapping braces. **Fix**: - Added a new internal `WriteContentsTo` method to `JsonObject` that writes properties without wrapping braces, handling both dictionary-backed and `JsonElement`-backed cases with proper optimization. - Added a `WriteExtensionDataValue` virtual method to `JsonConverter<T>` with a generic `T value` parameter that throws by default, overridden in `JsonObjectConverter` to call `WriteContentsTo`. This follows the same pattern as `ReadElementAndSetProperty` and avoids direct type references to `JsonObject` in `JsonConverterOfT.cs` to maintain trimming support. - Updated `TryWriteDataExtensionProperty` to call the virtual method instead of directly referencing `JsonObject`. - Retained a `Debug.Assert` for the `JsonObject` type check using a qualified `Nodes.JsonObject` reference (debug assertions are removed in release builds, so this doesn't affect trimming). # Customer Impact Serialization of any class with `[JsonExtensionData]` of type `JsonObject` produces malformed JSON that cannot be parsed. # Regression No. Reproducible from .NET 6 through .NET 8+. Deserialization works correctly; only serialization was affected. # Testing - Added 4 targeted tests covering: valid JSON output, round-trip, empty `JsonObject`, and null `JsonObject` - All 49,808 existing `System.Text.Json.Tests` pass - All 7,626 source generation tests pass - Registered new test class in source generator contexts (`ExtensionDataTestsContext_Metadata` and `ExtensionDataTestsContext_Default`) # Risk Low. Change is minimal and isolated to the `JsonObject` branch of extension data serialization. Dictionary extension data path is unchanged. The virtual method pattern maintains trimming support by avoiding direct type references in non-debug code paths. # Package authoring no longer needed in .NET 9 IMPORTANT: Starting with .NET 9, you no longer need to edit a NuGet package's csproj to enable building and bump the version. Keep in mind that we still need package authoring in .NET 8 and older versions.  <details> <summary>Original prompt</summary> > > ---- > > *This section details on the original issue you should resolve* > > <issue_title>JsonSerializer.Serialize produces invalid JSON for [JsonExtensionData] property</issue_title> > <issue_description>### Description > > When serializing object containing property marked with `[JsonExtensionData]` attribute, serializer produces invalid JSON like this one: `{"Id":1,{"nested":true}}` > > ### Reproduction Steps > > Run the following code > > ```C# > var mix = new Mix > { > Id = 1, > Extra = new() { ["nested"] = true, } > }; > > var text = System.Text.Json.JsonSerializer.Serialize(mix); > Console.WriteLine(text); > // output {"Id":1,{"nested":true}} > > > public class Mix > { > public int Id { get; set; } > > [System.Text.Json.Serialization.JsonExtensionData] > public System.Text.Json.Nodes.JsonObject? Extra { get; set; } > } > > ``` > > ### Expected behavior > > Correct JSON like `{"Id":1,"nested":true}` or at least valid JSON as if there was not `[JsonExtensionData]` attribute (`{"Id":1,"Extra":{"nested":true}}` ). > > ### Actual behavior > > Invalid JSON `{"Id":1,{"nested":true}}` > > ### Regression? > > Reproducible at least on .Net 6 to .Net 8 > > ### Known Workarounds > > _No response_ > > ### Configuration > > .Net 8 > Windows 11 > x64 > > ### Other information > > _No response_</issue_description> > > ## Comments on the Issue (you are @copilot in this section) > > <comments> > <comment_new><author>@</author><body> > Tagging subscribers to this area: @dotnet/area-system-text-json, @gregsdennis > See info in [area-owners.md](https://github.com/dotnet/runtime/blob/main/docs/area-owners.md) if you want to be subscribed. > <details> > <summary>Issue Details</summary> > <hr /> > > ### Description > > When serializing object containing property marked with `[JsonExtensionData]` attribute, serializer produces invalid JSON like this one: `{"Id":1,{"nested":true}}` > > ### Reproduction Steps > > Run the following code > > ```C# > var mix = new Mix > { > Id = 1, > Extra = new() { ["nested"] = true, } > }; > > var text = System.Text.Json.JsonSerializer.Serialize(mix); > Console.WriteLine(text); > // output {"Id":1,{"nested":true}} > > > public class Mix > { > public int Id { get; set; } > > [System.Text.Json.Serialization.JsonExtensionData] > public System.Text.Json.Nodes.JsonObject? Extra { get; set; } > } > > ``` > > ### Expected behavior > > Correct JSON like `{"Id":1,"nested":true}` or at least valid JSON as if there was not `[JsonExtensionData]` attribute (`{"Id":1,"Extra":{"nested":true}}` ). > > ### Actual behavior > > Invalid JSON `{"Id":1,{"nested":true}}` > > ### Regression? > > Reproducible at least on .Net 6 to .Net 8 > > ### Known Workarounds > > _No response_ > > ### Configuration > > .Net 8 > Windows 11 > x64 > > ### Other information > > _No response_ > > <table> > <tr> > <th align="left">Author:</th> > <td>KalininAndreyVictorovich</td> > </tr> > <tr> > <th align="left">Assignees:</th> > <td>-</td> > </tr> > <tr> > <th align="left">Labels:</th> > <td> > > `area-System.Text.Json` > > </td> > </tr> > <tr> > <th align="left">Milestone:</th> > <td>-</td> > </tr> > </table> > </details></body></comment_new> > <comment_new><author>@eiriktsarpalis</author><body> > Can confirm that this occurs. It seems we never added testing for the serialization scenario -- deserialization appears to be working as expected.</body></comment_new> > <comment_new><author>@eiriktsarpalis</author><body> > The documentation is correctly stating that `JsonObject` is one of the supported types. However there is a bug specifically impacting serialization for the particular type (FWIW `JsonExtensionData` is a feature primarily oriented towards dserialization).</body></comment_new> > <comment_new><author>@eiriktsarpalis</author><body> > You're right, I misread the documentation which appears to be out of date. The correct statement on supported types can actually be found in the error messages of the implementation itself: > > https://github.com/dotnet/runtime/blob/2d751cac7311b344c237df3b3c63b33434b52217/src/libraries/System.Text.Json/gen/Resources/Strings.resx#L150-L152 > > In other words, what I mentioned earlier holds. `JsonObject` _is_ supported and there is a bug specifically concerning serialization.</body></comment_new> > <comment_new><author>@eiriktsarpalis</author><body> > It would help if you could file a separate issue in dotnet-api-docs. Thanks!</body></comment_new> > </comments> > </details>  - Fixes #97225  --- ✨ Let Copilot coding agent [set things up for you](https://github.com/dotnet/runtime/issues/new?title=✨+Set+up+Copilot+instructions&body=Configure%20instructions%20for%20this%20repository%20as%20documented%20in%20%5BBest%20practices%20for%20Copilot%20coding%20agent%20in%20your%20repository%5D%28https://gh.io/copilot-coding-agent-tips%29%2E%0A%0A%3COnboard%20this%20repo%3E&assignees=copilot) — coding agent works faster and does higher quality work when set up for your repo. --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> Co-authored-by: Stephen Toub <stoub@microsoft.com> Co-authored-by: eiriktsarpalis <2813363+eiriktsarpalis@users.noreply.github.com>
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs
@@ -172,7 +172,30 @@ public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? optio
             else
             {
                 writer.WriteStartObject();
+                WriteContentsTo(writer, options);
+                writer.WriteEndObject();
+            }
+        }
 
+        /// <summary>
+        /// Writes the properties of this JsonObject to the writer without the surrounding braces.
+        /// This is used for extension data serialization where the properties should be flattened
+        /// into the parent object.
+        /// </summary>
+        internal void WriteContentsTo(Utf8JsonWriter writer, JsonSerializerOptions? options)
+        {
+            GetUnderlyingRepresentation(out OrderedDictionary<string, JsonNode?>? dictionary, out JsonElement? jsonElement);
+
+            if (dictionary is null && jsonElement.HasValue)
+            {
+                // Write properties from the underlying JsonElement without converting to nodes.
+                foreach (JsonProperty property in jsonElement.Value.EnumerateObject())
+                {
+                    property.WriteTo(writer);
+                }
+            }
+            else
+            {
                 foreach (KeyValuePair<string, JsonNode?> entry in Dictionary)
                 {
                     writer.WritePropertyName(entry.Key);
@@ -186,8 +209,6 @@ public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? optio
                         entry.Value.WriteTo(writer, options);
                     }
                 }
-
-                writer.WriteEndObject();
             }
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Node/JsonObjectConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Node/JsonObjectConverter.cs
@@ -41,6 +41,12 @@ internal override void ReadElementAndSetProperty(
             }
         }
 
+        internal override void WriteExtensionDataValue(Utf8JsonWriter writer, JsonObject? value, JsonSerializerOptions options)
+        {
+            Debug.Assert(value is not null);
+            value.WriteContentsTo(writer, options);
+        }
+
         public override void Write(Utf8JsonWriter writer, JsonObject? value, JsonSerializerOptions options)
         {
             if (value is null)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs
@@ -458,8 +458,11 @@ internal bool TryWriteDataExtensionProperty(Utf8JsonWriter writer, T value, Json
             {
                 // If not JsonDictionaryConverter<T> then we are JsonObject.
                 // Avoid a type reference to JsonObject and its converter to support trimming.
+                // The WriteExtensionDataValue virtual method is overridden by the JsonObject converter.
                 Debug.Assert(Type == typeof(Nodes.JsonObject));
-                return TryWrite(writer, value, options, ref state);
+                WriteExtensionDataValue(writer, value!, options);
+
+                return true;
             }
 
             if (writer.CurrentDepth >= options.EffectiveMaxDepth)
@@ -493,6 +496,19 @@ internal bool TryWriteDataExtensionProperty(Utf8JsonWriter writer, T value, Json
             return success;
         }
 
+        /// <summary>
+        /// Used to support JsonObject as an extension property in a loosely-typed, trimmable manner.
+        /// </summary>
+        /// <remarks>
+        /// Writes the extension data contents without wrapping object braces.
+        /// </remarks>
+        internal virtual void WriteExtensionDataValue(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        {
+            Debug.Fail("Should not be reachable.");
+
+            throw new InvalidOperationException();
+        }
+
         /// <inheritdoc/>
         public sealed override Type Type { get; } = typeof(T);
 
diff --git a/src/libraries/System.Text.Json/tests/Common/ExtensionDataTests.cs b/src/libraries/System.Text.Json/tests/Common/ExtensionDataTests.cs
@@ -815,6 +815,100 @@ public async Task DeserializeIntoJsonObjectProperty()
             Assert.Equal(1, obj.MyOverflow["MyDict"]["Property1"].GetValue<int>());
         }
 
+        [Fact]
+        public async Task SerializeJsonObjectExtensionData_ProducesValidJson()
+        {
+            // JsonSerializer.Serialize was producing invalid JSON for [JsonExtensionData] property of type JsonObject
+            // Output was: {"Id":1,{"nested":true}} instead of {"Id":1,"nested":true}
+
+            var obj = new ClassWithJsonObjectExtensionDataAndProperty
+            {
+                Id = 1,
+                Extra = new JsonObject { ["nested"] = true }
+            };
+
+            string json = await Serializer.SerializeWrapper(obj);
+
+            // Verify the JSON is valid by parsing it
+            using JsonDocument doc = JsonDocument.Parse(json);
+
+            // Verify the structure is correct: extension data should be flattened, not nested
+            Assert.True(doc.RootElement.TryGetProperty("Id", out JsonElement idElement));
+            Assert.Equal(1, idElement.GetInt32());
+
+            Assert.True(doc.RootElement.TryGetProperty("nested", out JsonElement nestedElement));
+            Assert.True(nestedElement.GetBoolean());
+
+            // Extension data property name should NOT appear in the output
+            Assert.False(doc.RootElement.TryGetProperty("Extra", out _));
+
+            // Verify expected JSON format
+            Assert.Equal(@"{""Id"":1,""nested"":true}", json);
+        }
+
+        [Fact]
+        public async Task SerializeJsonObjectExtensionData_RoundTrip()
+        {
+            var original = new ClassWithJsonObjectExtensionDataAndProperty
+            {
+                Id = 42,
+                Extra = new JsonObject
+                {
+                    ["string"] = "value",
+                    ["number"] = 123,
+                    ["boolean"] = false,
+                    ["nested"] = new JsonObject { ["inner"] = "data" }
+                }
+            };
+
+            string json = await Serializer.SerializeWrapper(original);
+
+            // Verify round-trip
+            var deserialized = await Serializer.DeserializeWrapper<ClassWithJsonObjectExtensionDataAndProperty>(json);
+
+            Assert.Equal(original.Id, deserialized.Id);
+            Assert.NotNull(deserialized.Extra);
+            Assert.Equal(4, deserialized.Extra.Count);
+            Assert.Equal("value", deserialized.Extra["string"]!.GetValue<string>());
+            Assert.Equal(123, deserialized.Extra["number"]!.GetValue<int>());
+            Assert.False(deserialized.Extra["boolean"]!.GetValue<bool>());
+            Assert.Equal("data", deserialized.Extra["nested"]!["inner"]!.GetValue<string>());
+        }
+
+        [Fact]
+        public async Task SerializeJsonObjectExtensionData_EmptyJsonObject()
+        {
+            var obj = new ClassWithJsonObjectExtensionDataAndProperty
+            {
+                Id = 1,
+                Extra = new JsonObject()
+            };
+
+            string json = await Serializer.SerializeWrapper(obj);
+            Assert.Equal(@"{""Id"":1}", json);
+        }
+
+        [Fact]
+        public async Task SerializeJsonObjectExtensionData_NullJsonObject()
+        {
+            var obj = new ClassWithJsonObjectExtensionDataAndProperty
+            {
+                Id = 1,
+                Extra = null
+            };
+
+            string json = await Serializer.SerializeWrapper(obj);
+            Assert.Equal(@"{""Id"":1}", json);
+        }
+
+        public class ClassWithJsonObjectExtensionDataAndProperty
+        {
+            public int Id { get; set; }
+
+            [JsonExtensionData]
+            public JsonObject? Extra { get; set; }
+        }
+
         [Fact]
 #if BUILDING_SOURCE_GENERATOR_TESTS
         [ActiveIssue("https://github.com/dotnet/runtime/issues/58945")]
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ExtensionDataTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ExtensionDataTests.cs
@@ -74,6 +74,7 @@ public ExtensionDataTests_Metadata()
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryExtensionPropertyAsJsonElementWithProperty))]
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryAlreadyInstantiated))]
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryJsonElementAlreadyInstantiated))]
+        [JsonSerializable(typeof(ClassWithJsonObjectExtensionDataAndProperty))]
         internal sealed partial class ExtensionDataTestsContext_Metadata : JsonSerializerContext
         {
         }
@@ -144,6 +145,7 @@ public ExtensionDataTests_Default()
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryExtensionPropertyAsJsonElementWithProperty))]
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryAlreadyInstantiated))]
         [JsonSerializable(typeof(ClassWithIReadOnlyDictionaryJsonElementAlreadyInstantiated))]
+        [JsonSerializable(typeof(ClassWithJsonObjectExtensionDataAndProperty))]
         internal sealed partial class ExtensionDataTestsContext_Default : JsonSerializerContext
         {
         }

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,12 @@ internal override void ReadElementAndSetProperty(`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
	`44`	`+ internal override void WriteExtensionDataValue(Utf8JsonWriter writer, JsonObject? value, JsonSerializerOptions options)`
	`45`	`+ {`
	`46`	`+ Debug.Assert(value is not null);`
	`47`	`+ value.WriteContentsTo(writer, options);`
	`48`	`+ }`
	`49`	`+`
`44`	`50`	`public override void Write(Utf8JsonWriter writer, JsonObject? value, JsonSerializerOptions options)`
`45`	`51`	`{`
`46`	`52`	`if (value is null)`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ public ExtensionDataTests_Metadata()`
`74`	`74`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryExtensionPropertyAsJsonElementWithProperty))]`
`75`	`75`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryAlreadyInstantiated))]`
`76`	`76`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryJsonElementAlreadyInstantiated))]`
	`77`	`+ [JsonSerializable(typeof(ClassWithJsonObjectExtensionDataAndProperty))]`
`77`	`78`	`internal sealed partial class ExtensionDataTestsContext_Metadata : JsonSerializerContext`
`78`	`79`	`{`
`79`	`80`	`}`
`@@ -144,6 +145,7 @@ public ExtensionDataTests_Default()`
`144`	`145`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryExtensionPropertyAsJsonElementWithProperty))]`
`145`	`146`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryAlreadyInstantiated))]`
`146`	`147`	`[JsonSerializable(typeof(ClassWithIReadOnlyDictionaryJsonElementAlreadyInstantiated))]`
	`148`	`+ [JsonSerializable(typeof(ClassWithJsonObjectExtensionDataAndProperty))]`
`147`	`149`	`internal sealed partial class ExtensionDataTestsContext_Default : JsonSerializerContext`
`148`	`150`	`{`
`149`	`151`	`}`