IGNITE-18438 .NET: Fix marshalling of nested binarizable structures with different schemas. (apache#10484)

Author: ivandasch

modules/platforms/dotnet/Apache.Ignite.Core.Tests/Binary/BinaryStructureTest.cs

@@ -18,6 +18,7 @@
 namespace Apache.Ignite.Core.Tests.Binary
 {
     using System;
+    using System.Collections;
     using System.Collections.Generic;
     using System.Diagnostics.CodeAnalysis;
     using System.IO;
@@ -211,6 +212,90 @@ public void TestMultithreadedRandomFields()
 
             }, Environment.ProcessorCount, 5);
         }
+        
+        /// <summary>
+        /// Test serializing nested binarizable objects with different schemas.
+        /// </summary>
+        [Test]
+        public void TestSerializeNestedStructureWithDifferentSchemas()
+        {
+            var marsh = new Marshaller(new BinaryConfiguration(typeof(Item)));
+            
+            var simple = new Item(new List<string> { "f1", "f2" });
+            var nested = new Item(new List<string> { "f3" }, 
+                new List<Item> {new Item(new List<string> { "f1" })}); 
+
+            var simpleMarsh = marsh.Marshal(simple);
+            var nestedMarsh = marsh.Marshal(nested);
+            
+            Assert.AreEqual(new List<string> {"f1", "f2"}, marsh.Unmarshal<Item>(simpleMarsh).FieldNames);
+            Assert.IsEmpty(marsh.Unmarshal<Item>(simpleMarsh).Children);
+            
+            Assert.AreEqual(new List<string> { "f3" }, marsh.Unmarshal<Item>(nestedMarsh).FieldNames);
+            Assert.AreEqual(1, marsh.Unmarshal<Item>(nestedMarsh).Children.Count);
+            Assert.AreEqual(new List<string> { "f1" }, marsh.Unmarshal<Item>(nestedMarsh).Children[0].FieldNames);
+            Assert.IsEmpty(marsh.Unmarshal<Item>(nestedMarsh).Children[0].Children);
+        }
+    }
+
+    /// <summary>
+    /// A composite structure consisting of the specified fields and optional children of the same
+    /// <see cref="Item"/> type.
+    /// </summary>
+    class Item : IBinarizable
+    {
+        private List<string> _fieldNames;
+        private List<Item> _children;
+
+        public Item(List<string> fieldNames, List<Item> children)
+        {
+            _fieldNames = fieldNames;
+            _children = children;
+        }
+
+        public Item(List<string> fieldNames)
+            : this(fieldNames, new List<Item>())
+        {
+        }
+
+        public List<string> FieldNames
+        {
+            get { return _fieldNames;  }
+        }
+        
+        public List<Item> Children
+        {
+            get { return _children;  }
+        }
+
+        public void WriteBinary(IBinaryWriter writer)
+        {
+            writer.WriteCollection(nameof(_children), _children);
+            writer.WriteCollection(nameof(_fieldNames), _fieldNames);
+
+            foreach (var name in _fieldNames)
+            {
+                writer.WriteString(name, name);
+            }
+        }
+
+        public void ReadBinary(IBinaryReader reader)
+        {
+            _children = (List<Item>)reader.ReadCollection(
+                nameof(_children),
+                size => new List<Item>(size),
+                (collection, obj) => ((List<Item>) collection).Add((Item) obj));
+            
+            _fieldNames = (List<string>)reader.ReadCollection(
+                nameof(_fieldNames),
+                size => new List<string>(size),
+                (collection, obj) => ((List<string>) collection).Add((string) obj));
+
+            foreach (var name in _fieldNames)
+            {
+                Assert.AreEqual(name, reader.ReadString(name));
+            }
+        }
     }
 
     [SuppressMessage("ReSharper", "InconsistentNaming")]

modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/Metadata/BinaryType.cs

@@ -19,7 +19,6 @@ namespace Apache.Ignite.Core.Impl.Binary.Metadata
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
     using System.Diagnostics.CodeAnalysis;
     using System.Linq;
     using Apache.Ignite.Core.Binary;
@@ -34,12 +33,6 @@ internal class BinaryType : IBinaryType
         public static readonly BinaryType Empty =
             new BinaryType(BinaryTypeId.Object, BinaryTypeNames.TypeNameObject, null, null, false, null, null, null);
 
-        /** Empty dictionary. */
-        private static readonly IDictionary<string, BinaryField> EmptyDict = new Dictionary<string, BinaryField>();
-
-        /** Empty list. */
-        private static readonly ICollection<string> EmptyList = new List<string>().AsReadOnly();
-
         /** Type name map. */
         private static readonly string[] TypeNames = new string[byte.MaxValue];
 
@@ -219,7 +212,9 @@ public BinaryType(int typeId, string typeName, IDictionary<string, BinaryField>
             _typeId = typeId;
             _typeName = typeName;
             _affinityKeyFieldName = affKeyFieldName;
-            _fields = fields;
+
+            _fields = fields ?? new Dictionary<string, BinaryField>();
+
             _isEnum = isEnum;
             _enumNameToValue = enumValues;
 
@@ -254,7 +249,7 @@ public string TypeName
         /// </summary>
         public ICollection<string> Fields
         {
-            get { return _fields != null ? _fields.Keys : EmptyList; }
+            get { return _fields.Keys; }
         }
 
         /// <summary>
@@ -268,19 +263,14 @@ public string GetFieldTypeName(string fieldName)
         {
             IgniteArgumentCheck.NotNullOrEmpty(fieldName, "fieldName");
 
-            if (_fields != null)
-            {
-                BinaryField fieldMeta;
-
-                if (!_fields.TryGetValue(fieldName, out fieldMeta))
-                {
-                    throw new BinaryObjectException("BinaryObject field does not exist: " + fieldName);
-                }
+            BinaryField fieldMeta;
 
-                return GetTypeName(fieldMeta.TypeId);
+            if (!_fields.TryGetValue(fieldName, out fieldMeta))
+            {
+                throw new BinaryObjectException("BinaryObject field does not exist: " + fieldName);
             }
-            
-            return null;
+
+            return GetTypeName(fieldMeta.TypeId);
         }
 
         /// <summary>
@@ -332,7 +322,7 @@ public IBinaryTypeDescriptor Descriptor
         /// <returns>Fields map.</returns>
         public IDictionary<string, BinaryField> GetFieldsMap()
         {
-            return _fields ?? EmptyDict;
+            return _fields;
         }
 
         /// <summary>
@@ -359,8 +349,6 @@ public void UpdateFields(IDictionary<string, BinaryField> fields)
             if (fields == null || fields.Count == 0)
                 return;
 
-            Debug.Assert(_fields != null);
-
             foreach (var field in fields)
                 _fields[field.Key] = field.Value;
         }