fix: Handle initial collection items appropriately (#2702)

Author: Eideren

sources/assets/Stride.Core.Assets.Tests/Yaml/TestCollectionIdsSerialization.cs

@@ -62,6 +62,28 @@ public ContainerNonIdentifiableDictionary(string name)
         public Dictionary<string, ContainerCollection> NonIdentifiableObjects { get; set; } = [];
     }
 
+    public class ContainerCollectionWithInitialData
+    {
+        public List<string> Strings { get; set; } = ["InitialData"];
+    }
+
+    public class ContainerDictionaryWithInitialData
+    {
+        public Dictionary<string, string> Strings { get; set; } = new() { { "InitialDataK", "InitialDataV" } };
+    }
+
+    public class ContainerCollectionWithInitialDataNonId
+    {
+        [NonIdentifiableCollectionItems]
+        public List<string> Strings { get; set; } = ["InitialDataNonId"];
+    }
+
+    public class ContainerDictionaryWithInitialDataNonId
+    {
+        [NonIdentifiableCollectionItems]
+        public Dictionary<string, string> Strings { get; set; } = new() { { "InitialDataNonIdK", "InitialDataNonIdV" } };
+    }
+
 
     private const string YamlCollection =
         """
@@ -671,4 +693,51 @@ public void TestIdsGeneration()
         hashSet.Add(ids["key4"]);
         Assert.Equal(5, hashSet.Count);
     }
+
+    [Fact]
+    public void TestCollectionWithInitialDataSerialization()
+    {
+        var output = RoundTrip(new ContainerCollectionWithInitialData
+        {
+            Strings = new() { "ReplacedData" }
+        });
+        Assert.NotNull(output);
+        Assert.Single(output.Strings);
+        Assert.Equal("ReplacedData", output.Strings[0]);
+        
+        var output2 = RoundTrip(new ContainerDictionaryWithInitialData
+        {
+            Strings = new() { { "ReplacedDataK", "ReplacedDataV" } }
+        });
+        Assert.NotNull(output2);
+        Assert.Single(output2.Strings);
+        Assert.Equal(new KeyValuePair<string, string>("ReplacedDataK", "ReplacedDataV"), output2.Strings.First());
+        
+        var output3 = RoundTrip(new ContainerCollectionWithInitialDataNonId
+        {
+            Strings = new() { "ReplacedData" }
+        });
+        Assert.NotNull(output3);
+        Assert.Single(output3.Strings);
+        Assert.Equal("ReplacedData", output3.Strings[0]);
+        
+        var output4 = RoundTrip(new ContainerDictionaryWithInitialDataNonId
+        {
+            Strings = new() { { "ReplacedDataK", "ReplacedDataV" } }
+        });
+        Assert.NotNull(output4);
+        Assert.Single(output4.Strings);
+        Assert.Equal(new KeyValuePair<string, string>("ReplacedDataK", "ReplacedDataV"), output4.Strings.First());
+
+        static T? RoundTrip<T>(T instance) where T : class
+        {
+            var yaml = SerializeAsString(instance);
+            var stream = new MemoryStream();
+            var writer = new StreamWriter(stream);
+            writer.Write(yaml);
+            writer.Flush();
+            stream.Position = 0;
+            return AssetYamlSerializer.Default.Deserialize(stream) as T;
+        }
+    }
 }

sources/assets/Stride.Core.Assets/Yaml/CollectionWithIdsSerializer.cs

@@ -114,6 +114,11 @@ protected override void TransformAfterDeserialization(IDictionary container, ITy
             throw new InvalidOperationException("The given container does not match the expected type.");
         var identifier = CollectionItemIdHelper.GetCollectionItemIds(targetCollection);
         identifier.Clear();
+
+        // The collection may contain some initial data from its containing instance's ctor,
+        // let's replace the existing data with the data we have serialized
+        collectionDescriptor.Clear(targetCollection);
+
         var i = 0;
         var enumerator = container.GetEnumerator();
         while (enumerator.MoveNext())

sources/assets/Stride.Core.Assets/Yaml/CollectionWithIdsSerializerBase.cs

@@ -133,6 +133,10 @@ protected override void ReadDictionaryItems(ref ObjectContext objectContext)
     {
         var dictionaryDescriptor = (DictionaryDescriptor)objectContext.Descriptor;
 
+        // The collection may contain some initial data from its containing instance's ctor,
+        // let's replace the existing data with the data we have serialized
+        dictionaryDescriptor.Clear(objectContext.Instance);
+
         var deletedItems = new HashSet<ItemId>();
 
         var reader = objectContext.Reader;

sources/assets/Stride.Core.Assets/Yaml/DictionaryWithIdsSerializer.cs

@@ -97,6 +97,11 @@ protected override void TransformAfterDeserialization(IDictionary container, ITy
             throw new InvalidOperationException("The given container does not match the expected type.");
         var identifier = CollectionItemIdHelper.GetCollectionItemIds(targetCollection);
         identifier.Clear();
+
+        // The collection may contain some initial data from its containing instance's ctor,
+        // let's replace the existing data with the data we have serialized
+        dictionaryDescriptor.Clear(targetCollection);
+
         var enumerator = container.GetEnumerator();
         while (enumerator.MoveNext())
         {

sources/core/Stride.Core.Reflection/TypeDescriptors/DictionaryDescriptor.cs

@@ -22,6 +22,7 @@ public class DictionaryDescriptor : ObjectDescriptor
     Func<object, ICollection> getValuesMethod;
     Func<object, object, object?> getValueMethod;
     Func<object, IEnumerable<KeyValuePair<object, object?>>> getEnumeratorMethod;
+    Action<object> clearMethod;
 
     #pragma warning disable CS8618
     // This warning is disabled because the necessary initialization will occur 
@@ -56,6 +57,7 @@ void CreateDictionaryDelegates<TKey, TValue>()
         getValueMethod = (dictionary, key) => ((IDictionary<TKey, TValue?>)dictionary)[(TKey)key];
         setValueMethod = (dictionary, key, value) => ((IDictionary<TKey, TValue?>)dictionary)[(TKey)key] = (TValue?)value;
         getEnumeratorMethod = (dictionary) => GetGenericEnumerable((IDictionary<TKey, TValue>)dictionary);
+        clearMethod = (dictionary) => ((IDictionary<TKey, TValue?>)dictionary).Clear();
     }
 
     public override void Initialize(IComparer<object> keyComparer)
@@ -182,6 +184,16 @@ public ICollection GetValues(object dictionary)
         return getValuesMethod(dictionary);
     }
 
+    /// <summary>
+    /// Calls clear on the dictionary
+    /// </summary>
+    /// <param name="dictionary">The dictionary</param>
+    public void Clear(object dictionary)
+    {
+        ArgumentNullException.ThrowIfNull(dictionary);
+        clearMethod(dictionary);
+    }
+
     /// <summary>
     /// Returns the value matching the given key in the dictionary, or null if the key is not found
     /// </summary>

sources/core/Stride.Core.Yaml/Serialization/Serializers/CollectionSerializer.cs

@@ -148,6 +148,10 @@ protected virtual void ReadCollectionItems(ref ObjectContext objectContext)
                 throw new InvalidOperationException($"Cannot deserialize collection to readonly collection type [{thisObject.GetType()}].");
             }
 
+            // The collection may contain some initial data from its containing instance's ctor,
+            // let's replace the existing data with the data we have serialized
+            collectionDescriptor.Clear(thisObject);
+
             var reader = objectContext.Reader;
 
             var elementType = collectionDescriptor.ElementType;

sources/core/Stride.Core.Yaml/Serialization/Serializers/DictionarySerializer.cs

@@ -141,6 +141,8 @@ protected virtual void ReadDictionaryItems(ref ObjectContext objectContext)
         {
             var dictionaryDescriptor = (DictionaryDescriptor)objectContext.Descriptor;
 
+            dictionaryDescriptor.Clear(objectContext.Instance);
+
             var reader = objectContext.Reader;
             while (!reader.Accept<MappingEnd>())
             {