Avoid materializing dictionaries when serializing

Author: xoofx

src/SharpYaml.Tests/Serialization/YamlOrderedDictionaryConverterTests.cs

@@ -19,6 +19,20 @@ internal sealed class OrderedDictionaryObjectModel
     public OrderedDictionary<string, object> Items { get; set; } = new();
 }
 
+internal sealed class OrderedDictionaryReferenceModel
+{
+    public OrderedDictionary<string, int>? Primary { get; set; }
+
+    public OrderedDictionary<string, int>? Secondary { get; set; }
+}
+
+internal sealed class OrderedDictionaryGenericReferenceModel
+{
+    public OrderedDictionary<int, string>? Primary { get; set; }
+
+    public OrderedDictionary<int, string>? Secondary { get; set; }
+}
+
 [YamlSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
 [YamlSerializable(typeof(OrderedDictionary<string, int>))]
 [YamlSerializable(typeof(OrderedDictionary<string, string>))]
@@ -128,6 +142,70 @@ public void Reflection_RoundTrip_PreservesOrder()
         CollectionAssert.AreEqual(originalKeys, resultKeys);
     }
 
+    [TestMethod]
+    public void Reflection_RoundTrip_StringKeyOrderedDictionary_ShouldPreserveSharedReferences()
+    {
+        var shared = new OrderedDictionary<string, int>
+        {
+            { "zebra", 1 },
+            { "apple", 2 },
+        };
+
+        var payload = new OrderedDictionaryReferenceModel
+        {
+            Primary = shared,
+            Secondary = shared,
+        };
+
+        var options = new YamlSerializerOptions { ReferenceHandling = YamlReferenceHandling.Preserve };
+        var yaml = YamlSerializer.Serialize(payload, options);
+
+        var anchor = ExtractAnchor(yaml, "Primary: &");
+        StringAssert.Contains(yaml, $"Secondary: *{anchor}");
+
+        var result = YamlSerializer.Deserialize<OrderedDictionaryReferenceModel>(yaml, options);
+
+        Assert.IsNotNull(result);
+        Assert.IsNotNull(result.Primary);
+        Assert.IsNotNull(result.Secondary);
+        Assert.IsTrue(ReferenceEquals(result.Primary, result.Secondary));
+
+        var keys = new List<string>(result.Primary.Keys);
+        CollectionAssert.AreEqual(new[] { "zebra", "apple" }, keys);
+    }
+
+    [TestMethod]
+    public void Reflection_RoundTrip_GenericKeyOrderedDictionary_ShouldPreserveSharedReferences()
+    {
+        var shared = new OrderedDictionary<int, string>
+        {
+            { 3, "three" },
+            { 1, "one" },
+        };
+
+        var payload = new OrderedDictionaryGenericReferenceModel
+        {
+            Primary = shared,
+            Secondary = shared,
+        };
+
+        var options = new YamlSerializerOptions { ReferenceHandling = YamlReferenceHandling.Preserve };
+        var yaml = YamlSerializer.Serialize(payload, options);
+
+        var anchor = ExtractAnchor(yaml, "Primary: &");
+        StringAssert.Contains(yaml, $"Secondary: *{anchor}");
+
+        var result = YamlSerializer.Deserialize<OrderedDictionaryGenericReferenceModel>(yaml, options);
+
+        Assert.IsNotNull(result);
+        Assert.IsNotNull(result.Primary);
+        Assert.IsNotNull(result.Secondary);
+        Assert.IsTrue(ReferenceEquals(result.Primary, result.Secondary));
+
+        var keys = new List<int>(result.Primary.Keys);
+        CollectionAssert.AreEqual(new[] { 3, 1 }, keys);
+    }
+
     [TestMethod]
     public void Reflection_Deserialize_NullValue()
     {
@@ -284,4 +362,18 @@ public void SourceGen_Deserialize_WithCamelCaseNaming()
         Assert.IsNotNull(result);
         Assert.AreEqual(2, result.Count);
     }
+
+    private static string ExtractAnchor(string yaml, string prefix)
+    {
+        var anchorStart = yaml.IndexOf(prefix, StringComparison.Ordinal);
+        Assert.IsTrue(anchorStart >= 0, $"Expected '{prefix}' in YAML.");
+        anchorStart += prefix.Length;
+
+        var anchorEnd = yaml.IndexOf('\n', anchorStart);
+        Assert.IsTrue(anchorEnd > anchorStart, $"Expected an anchor after '{prefix}'.");
+
+        var anchor = yaml.Substring(anchorStart, anchorEnd - anchorStart).Trim();
+        Assert.AreNotEqual(string.Empty, anchor);
+        return anchor;
+    }
 }

src/SharpYaml.Tests/Serialization/YamlSerializerCollectionSupportReflectionTests.cs

@@ -60,6 +60,68 @@ public void Deserialize_IReadOnlyDictionaryWithEnumKeys_ShouldParseKeys()
         Assert.AreEqual(2, result[TestColor.Green]);
     }
 
+    [TestMethod]
+    public void RoundTrip_IDictionaryNonDictionaryImplementation_ShouldPreserveSharedReferences()
+    {
+        var shared = new SortedDictionary<int, string>
+        {
+            [2] = "two",
+            [1] = "one",
+        };
+
+        var payload = new DictionaryInterfacePayload
+        {
+            Primary = shared,
+            Secondary = shared,
+        };
+
+        var options = new YamlSerializerOptions { ReferenceHandling = YamlReferenceHandling.Preserve };
+        var yaml = YamlSerializer.Serialize(payload, options);
+
+        var anchor = ExtractAnchor(yaml, "Primary: &");
+        StringAssert.Contains(yaml, $"Secondary: *{anchor}");
+
+        var result = YamlSerializer.Deserialize<DictionaryInterfacePayload>(yaml, options);
+
+        Assert.IsNotNull(result);
+        Assert.IsNotNull(result.Primary);
+        Assert.IsNotNull(result.Secondary);
+        Assert.IsTrue(ReferenceEquals(result.Primary, result.Secondary));
+        Assert.AreEqual("one", result.Primary[1]);
+        Assert.AreEqual("two", result.Primary[2]);
+    }
+
+    [TestMethod]
+    public void RoundTrip_IReadOnlyDictionaryNonDictionaryImplementation_ShouldPreserveSharedReferences()
+    {
+        var shared = new SortedDictionary<TestColor, int>
+        {
+            [TestColor.Green] = 2,
+            [TestColor.Red] = 1,
+        };
+
+        var payload = new ReadOnlyDictionaryInterfacePayload
+        {
+            Primary = shared,
+            Secondary = shared,
+        };
+
+        var options = new YamlSerializerOptions { ReferenceHandling = YamlReferenceHandling.Preserve };
+        var yaml = YamlSerializer.Serialize(payload, options);
+
+        var anchor = ExtractAnchor(yaml, "Primary: &");
+        StringAssert.Contains(yaml, $"Secondary: *{anchor}");
+
+        var result = YamlSerializer.Deserialize<ReadOnlyDictionaryInterfacePayload>(yaml, options);
+
+        Assert.IsNotNull(result);
+        Assert.IsNotNull(result.Primary);
+        Assert.IsNotNull(result.Secondary);
+        Assert.IsTrue(ReferenceEquals(result.Primary, result.Secondary));
+        Assert.AreEqual(1, result.Primary[TestColor.Red]);
+        Assert.AreEqual(2, result.Primary[TestColor.Green]);
+    }
+
     [TestMethod]
     public void Serialize_DictionaryWithGuidKeys_ShouldUseInvariantFormat()
     {
@@ -164,4 +226,32 @@ private sealed class ImmutableArrayAnchorPayload
 
         public ImmutableArray<int> Other { get; set; }
     }
+
+    private sealed class DictionaryInterfacePayload
+    {
+        public IDictionary<int, string>? Primary { get; set; }
+
+        public IDictionary<int, string>? Secondary { get; set; }
+    }
+
+    private sealed class ReadOnlyDictionaryInterfacePayload
+    {
+        public IReadOnlyDictionary<TestColor, int>? Primary { get; set; }
+
+        public IReadOnlyDictionary<TestColor, int>? Secondary { get; set; }
+    }
+
+    private static string ExtractAnchor(string yaml, string prefix)
+    {
+        var anchorStart = yaml.IndexOf(prefix, StringComparison.Ordinal);
+        Assert.IsTrue(anchorStart >= 0, $"Expected '{prefix}' in YAML.");
+        anchorStart += prefix.Length;
+
+        var anchorEnd = yaml.IndexOf('\n', anchorStart);
+        Assert.IsTrue(anchorEnd > anchorStart, $"Expected an anchor after '{prefix}'.");
+
+        var anchor = yaml.Substring(anchorStart, anchorEnd - anchorStart).Trim();
+        Assert.AreNotEqual(string.Empty, anchor);
+        return anchor;
+    }
 }