ISerializable 与递归子级

Posted 2023-04-13

【中文标题】ISerializable 与递归子级

【英文标题】：ISerializable with recursive children

【发布时间】：2016-02-13 13:58:06

【问题描述】：

我想为一个 C# 类实现 ISerializable，它包含一个类似类型的子项列表。考虑以下示例：

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace serialisation

    [Serializable]
    internal class Nested : ISerializable
    
        public string Name  get; set; 

        public List<Nested> Children  get; set; 

        public Nested(string name)
        
            Name = name;
            Children = new List<Nested>();
        

        protected Nested(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
        
            Name = info.GetString("Name");

            // This doesn't work:
            Nested[] children = (Nested[])info.GetValue("Children", typeof(Nested[]));
            Children = new List<Nested>(children);

            // This works:
            // Children = (List<Nested>)info.GetValue("Children", typeof(List<Nested>));
        

        public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
        
            info.AddValue("Name", Name);

            // This doesn't work:
            info.AddValue("Children", Children.ToArray());

            // This works:
            //info.AddValue("Children", Children);
        
    

    internal class Program
    
        private static void Main(string[] args)
        
            // Generate a hierarchy
            Nested root = new Nested("root");
            Nested child1 = new Nested("child1");
            Nested child2 = new Nested("child2");
            Nested child3 = new Nested("child3");
            child1.Children.Add(child2);
            child1.Children.Add(child3);
            root.Children.Add(child1);

            Nested deserialized;
            BinaryFormatter binaryFmt = new BinaryFormatter();

            // Serialize
            using (var fs = new FileStream("Nested.xml", FileMode.OpenOrCreate))
            
                binaryFmt.Serialize(fs, root);
            

            // Deserialize
            using (var fs = new FileStream("Nested.xml", FileMode.OpenOrCreate))
            
                deserialized = (Nested)binaryFmt.Deserialize(fs);
            

            // deserialized.Children contains one null child
            Console.WriteLine("Original Name: 0", root.Name);
            Console.WriteLine("New Name: 0", deserialized.Name);
        
    

在上面的示例中，Nested.GetObjectData 和 Nested 的序列化构造函数被调用了 4 次，依次调用。

将子元素作为嵌套数组添加到序列化程序中，将在反序列化时返回大小正确的数组，但所有元素都将为空。

但是，将类型从嵌套数组更改为嵌套列表将在调用子项的构造函数后神奇地修复空元素。

我想知道的是：

嵌套列表有什么特别之处？ 推荐使用什么方法来序列化具有此类递归结构的类？

更新：

似乎还有一个额外的接口，IDeserializationCallback.OnDeserialization，它在反序列化发生后调用（调用顺序是不确定的）。您可以将反序列化的数组存储在构造函数的临时成员变量中，然后将其分配给此方法中的列表。除非我遗漏了什么，否则这似乎不太理想，因为您必须使用临时变量来混乱您的实现。

【问题讨论】：

我相信这是一个已经回答的类似问题：***.com/questions/4339602/…

几分钟前我也发现了同样的问题。我之前的搜索词一定不够具体...

【参考方案1】：

我会选择复合模式。下面的解决方案同时解决了BinaryFormatter（如在您的 Main 中）和 XmlSerializer 方法，如果您要使用它。 Composite 和 Component 替换你的 Nested 类。

[Serializable()]
[XmlRoot("component", Namespace="", IsNullable=false)]
public partial class CT_Component 

    [XmlAttribute("name")]
    public string Name  get; set;


[Serializable()]
[XmlRoot("composite", Namespace="", IsNullable=false)]
public partial class CT_Composite 

    [XmlElement("component", typeof(CT_Component))]
    [XmlElement("composite", typeof(CT_Composite))]
    public object[] Items  get; set; 

    [XmlAttribute("name")]
    public string Name  get; set; 

我从以下 xsd 创建了这些，我总是从 xsd 转到生成的类，因为我永远无法获得正确的属性装饰。它的要点是递归的CT_Composite 类型：

<xs:element name="component" type="CT_Component" />
<xs:element name="composite" type="CT_Composite" />
<xs:complexType name="CT_Component">
  <xs:attribute name="name" type="xs:string" use="required" />
</xs:complexType>
<xs:complexType name="CT_Composite" >
  <xs:choice minOccurs="1" maxOccurs="unbounded">
    <xs:element ref="component" />
    <xs:element name="composite" type="CT_Composite" />
  </xs:choice>
  <xs:attribute name="name" type="xs:string" use="required" />
</xs:complexType>

序列化代码相同。变量声明：

var composite = new CT_Composite() 
            Name = "root",
            Items = new object[] 
                new CT_Composite() 
                    Name = "child1",
                    Items = new object[] 
                        new CT_Component() Name="child2",
                        new CT_Component() Name="child3"
                       ;

如果你对模式更加正统，你可以使用：

[Serializable()]
[XmlRoot("component", Namespace="", IsNullable=false)]
public class Component 
    [XmlAttribute("name")] public string Name  get; set;


[Serializable()]
[XmlRoot("composite", Namespace="", IsNullable=false)]
public class Composite : Component 
    [XmlElement("component", typeof(Component))]
    [XmlElement("composite", typeof(Composite))]
    public object[] Items  get; set;