protobuf-net - 递归异常

Question

我在这段代码中遇到递归问题:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using ProtoBuf;

namespace ConsoleApplication4
{
[Serializable]
[ProtoContract(ImplicitFields = ImplicitFields.AllFields)]
public class GeneralWrapper<T> where T : new()
{
    public GeneralWrapper()
    {
        Datas = new T();
    }

    public T Datas { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        List<Document> _documents = new List<Document>();

        for (int i = 0; i < 100000; i++)
        {
            Document _document = new Document()
            {
                DocumentName = "asdadsf"
            };

            _documents.Add(_document);
        }

        BinaryFormatter _formatter = new BinaryFormatter();

        FileStream fs = new FileStream
            ("Person1.bin", FileMode.OpenOrCreate);

        ProtoBuf.Serializer.Serialize(fs, _documents);

        fs.Close();

        // Deserialize.
        fs = new FileStream
            ("Person1.bin", FileMode.OpenOrCreate);

        List<Document> _document22 = ProtoBuf.Serializer.Deserialize<List<Document>>(fs);

        fs.Close();
    }
}

[ProtoContract]
public class Document
{
    public Document()
    {
        _count = 234234924;

        Section = new Section();

        Section.SectionName = "sdfasd";
    }

    [ProtoMember(1)]
    public string DocumentName { get; set; }

    [ProtoMember(2)]
    Dictionary<string, List<string>> Hello { get; set; }
    [ProtoMember(3, AsReference=true)]
    public Section Section { get; set; }

    [ProtoMember(4)]
    private string _sectionName;
    [ProtoMember(5)]
    public string SectionName
    {
        get
        {
            return Section.SectionName;
        }

        set
        {
            _sectionName = value;

            Section.SectionName = _sectionName;
        }
    }

    public int _count;
    public int Count
    {
        get
        {
            return _count;
        }
    }
}

[Serializable]
[ProtoContract]
public class Section
{
    public Section()
    {
        Section1 = new SectionInner(this);

        Hellos = new List<GeneralWrapper<List<string>>>();

        GeneralWrapper<List<string>> _hello = new GeneralWrapper<List<string>>();

        _hello.Datas.Add("hello");

        Hellos.Add(_hello);

        DHello = new Dictionary<string, List<Section>>();

        if (!DHello.ContainsKey("asdf"))
        {
            List<Section> _dhello1 = new List<Section>();

            _dhello1.Add(this);

            DHello.Add("asdf", _dhello1);
        }
    }

    [ProtoMember(1, AsReference=true)]
    public SectionInner Section1 { get; set; }
    [ProtoMember(2)]
    public string SectionName { get; set; }

    [ProtoMember(3, AsReference=true)]
    public Dictionary<string, List<Section>> DHello { get; set; }

    List<GeneralWrapper<List<string>>> Hellos { get; set; }
}

[Serializable]
[ProtoContract]
public class SectionInner
{
    public SectionInner(Section section)
    {
        Section = section;
    }

    [ProtoMember(1, AsReference=true)]
    public Section Section { get; set; }
}

显然，我一开始就使代码非常递归，因为这与我的真实项目正在做的事情是一样的。问题似乎是这样的:

 Dictionary<string, List<Section>>

当没有任何东西被添加到这个字典时，一切都很好地序列化。如果将列表添加到具有特定键的字典中，就会发生递归。

protobuf-net 是否支持此代码/语法？

 Dictionary<string, List<Section>>

我是否需要将 List 放在外部包装类中，例如:

 Dictionary<string, Wrapper<List<Section>>>

感谢您的帮助。我是 protobuf-net 的新手。

Answer 1

首先 - 我必须指出，在构造函数中执行那么多设置并不是一个好主意。如果这表示您的实际代码，您可能希望在反序列化期间跳过构造函数 ([ProtoContract(SkipConstructor=true)])。如果它只是说明性的，那很好。

是的，支持字典和列表之类的东西，但是 *直接 不支持嵌套列表 - 所以 List<List<...>>目前还不行。你可能会用 Dictionary<TKey,List<...>> 摆脱它因为它的键值对已经充当了中间的包装器。

递归:protobuf-net 支持许多递归场景，但这是对正式规范的扩展。因此，您需要明确启用它，并注意:互操作这种情况并不容易，因为没有正式的规范；但是:[ProtoMember(n, AsReference=true)]在单个成员上启用对象跟踪。注意所有使用该对象的地方都必须标记为这样，否则它们将使用树序列化。

关于“为什么不直接支持递归”——因为:protobuf(正式规范)的行为与这里的大多数序列化程序一样，并且是一个树序列化程序。注意:XmlSerializer、JavascriptSerializer 和 DataContractSerializer(在默认模式下)之类的东西也是树序列化器，如果给定递归结构，它们将崩溃。这是正常的。 protobuf-net 在少数情况下特意允许这样做，但默认情况下无法启用它，因为它需要不同的数据布局，从而违背了跨平台数据规范的目的。

如果我遗漏了您的任何问题，请指出。