List Protobuf net-具有父引用的对象列表

我有一个关于父对象的简单类。所有对象都在一个列表中（甚至是父对象）。反序列化后是否可以保留引用

在我的代码中，我有如下内容：

    [ProtoContract]
    public class ProtoItem
    {
        [ProtoMember(1)]
        public int Value { get; set; }

        [ProtoMember(2, AsReference = true)]
        public ProtoItem BaseItem { get; set; }
    }

main看起来是这样的：

        static void Main()
        {
            var itemParent = new ProtoItem { Value = 1 };
            var item2 = new ProtoItem { Value = 2, BaseItem = itemParent };
            var item3 = new ProtoItem { Value = 3, BaseItem = itemParent };

            var parentListToWrite = new List<ProtoItem> {itemParent, item2, item3};

            const string file = "protofile.txt";
            try { File.Delete(file); }
            catch { };

            using (var fs = File.OpenWrite(file)) { Serializer.Serialize(fs,    
                 parentListToWrite); }

        List<ProtoItem> readList;
        using (var fs = File.OpenRead(file)) { readList = 
            Serializer.Deserialize<List<ProtoItem>>(fs); }

        if (readList[0] == readList[2].BaseItem)
        {
            //how to make it equal?
        }
        if (readList[0] == readList[1].BaseItem)
        {
            //how to make it equal?
        }
    }

static void Main（）
{
var itemParent=newprotoitem{Value=1}；
var item2=newprotoitem{Value=2，BaseItem=itemParent}；
var item3=newprotoitem{Value=3，BaseItem=itemParent}；
var parentListToWrite=新列表{itemParent，item2，item3}；
常量字符串file=“protofile.txt”；
尝试{File.Delete（File）；}
捕获{}；
使用（var fs=File.OpenWrite（File））{Serializer.Serialize（fs），
parentListToWrite）；}
列表读取列表；
使用（var fs=File.OpenRead（File））{readList=
序列化程序.反序列化（fs）；}
if（readList[0]==readList[2].BaseItem）
{
//如何使其平等？
}
if（readList[0]==readList[1].BaseItem）
{
//如何使其平等？
}
}

---

如果条件起作用，是否可以反序列化？

protobuf规范没有对象标识的概念。protobuf net确实可以（作为一个可选的启用功能），但它目前不能直接用于列表项，尽管我怀疑它可能应该这样做。由于它会破坏格式，但是，如果我修复了这个问题，它将需要显式启用

但是下面的代码今天仍然有效——请注意，我在这里所做的是将顶级列表项包装在一个只封装ProtoItem的包装器中，但这样做可以实现引用跟踪。不理想，但是：它有效

using ProtoBuf;
using System.Collections.Generic;
using System.IO;

[ProtoContract(AsReferenceDefault=true)]
public class ProtoItem
{
    [ProtoMember(1)]
    public int Value { get; set; }

    [ProtoMember(2)]
    public ProtoItem BaseItem { get; set; }
}
[ProtoContract]
public class Wrapper
{
    [ProtoMember(1, DataFormat = DataFormat.Group)]
    public ProtoItem Item { get;set; }

    public static implicit operator ProtoItem(Wrapper value)
    {
        return value == null ? null : value.Item;
    }
    public static implicit operator Wrapper(ProtoItem value)
    {
        return value == null ? null : new Wrapper { Item = value };
    }
}



static class Program
{

    static void Main()
    {
        var itemParent = new ProtoItem { Value = 1 };
        var item2 = new ProtoItem { Value = 2, BaseItem = itemParent };
        var item3 = new ProtoItem { Value = 3, BaseItem = itemParent };

        var parentListToWrite = new List<Wrapper> { itemParent, item2, item3 };

        const string file = "protofile.txt";
        try
        { File.Delete(file); }
        catch
        { };

        using (var fs = File.OpenWrite(file))
        {
            Serializer.Serialize(fs,
    parentListToWrite);
        }

        List<Wrapper> readList;
        using (var fs = File.OpenRead(file))
        {
            readList = Serializer.Deserialize<List<Wrapper>>(fs);
        }

        if (readList[0].Item == readList[2].Item.BaseItem)
        {
            //how to make it equal?
            System.Console.WriteLine("eq");
        }
        if (readList[0].Item == readList[1].Item.BaseItem)
        {
            //how to make it equal?
            System.Console.WriteLine("eq");
        }
    }
}

使用ProtoBuf；
使用System.Collections.Generic；
使用System.IO；
[协议（AsReferenceDefault=true）]
公共类原型项
{
[原成员（1）]
公共int值{get；set；}
[原成员（2）]
公共ProtoItem BaseItem{get；set；}
}
[原始合同]
公共类包装器
{
[原成员（1，DataFormat=DataFormat.Group）]
公共ProtoItem项{get；set；}
公共静态隐式运算符原型项（包装器值）
{
返回值==null？null:value.Item；
}
公共静态隐式运算符包装（ProtoItem值）
{
返回值==null？null：新包装{Item=value}；
}
}
静态类程序
{
静态void Main（）
{
var itemParent=newprotoitem{Value=1}；
var item2=newprotoitem{Value=2，BaseItem=itemParent}；
var item3=newprotoitem{Value=3，BaseItem=itemParent}；
var parentListToWrite=新列表{itemParent，item2，item3}；
常量字符串file=“protofile.txt”；
尝试
{File.Delete（文件）；}
抓住
{ };
使用（var fs=File.OpenWrite（File））
{
Serializer.Serialize（fs，
亲子关系；
}
列表读取列表；
使用（var fs=File.OpenRead（File））
{
readList=Serializer.Deserialize（fs）；
}
if（readList[0]。Item==readList[2]。Item.BaseItem）
{
//如何使其平等？
系统控制台写入线（“eq”）；
}
if（readList[0]。Item==readList[1]。Item.BaseItem）
{
//如何使其平等？
系统控制台写入线（“eq”）；
}
}
}

是否还有其他需要破解的收藏？我为列表添加了一个

AsReference=true