C# Protobuf net在与泛型一起用于反序列化时请求TypeModel.CS

我有几十亿个对象，我正试图将它们组织在一个序列化到硬盘的B+树中。我将库用于数据结构和序列化/反序列化。在这方面，我将我的类定义为：

    [ProtoContract]
    public class B<C, M>
        where C : IComparable<C>
        where M : IData<C>
    {
        internal B()
        {
            lambda = new List<Lambda<C, M>>();
            omega = 0;
        }

        internal B(C coordinate)
        {
            lambda = new List<Lambda<C, M>>();
            e = coordinate;
            omega = 0;
        }

        [ProtoMember(1)]
        internal C e { set; get; }

        [ProtoMember(2)]
        internal List<Lambda<C, M>> lambda { private set; get; }

        [ProtoMember(3)]
        internal int omega { set; get; }
    }


[ProtoContract]
public class Lambda<C, M>
    where C : IComparable<C>
    where M : IData<C>
{
    internal Lambda() { }

    internal Lambda(char tau, M atI)
    {
        this.tau = tau;
        this.atI = atI;
    }

    [ProtoMember(1)]
    internal char tau { private set; get; }

    [ProtoMember(2)]
    internal M atI { private set; get; }
}

[协议]
公共B级
其中C:i可比较
M:IData在哪里
{
内部B（）
{
lambda=新列表（）；
ω=0；
}
内部B（C坐标）
{
lambda=新列表（）；
e=坐标；
ω=0；
}
[原成员（1）]
内部C{set；get；}
[原成员（2）]
内部列表lambda{private set；get；}
[原成员（3）]
内部intω{set；get；}
}
[原始合同]
公共级Lambda
其中C:i可比较
M:IData在哪里
{
内部Lambda（）{}
内部Lambda（char tau，M atI）
{
this.tau=tau；
this.atI=atI；
}
[原成员（1）]
内部字符tau{private set；get；}
[原成员（2）]
内部M atI{private set；get；}
}

我将序列化器/反序列化器定义如下：

public class BSerializer<C, M> : ISerializer<B<C, M>>
        where C : IComparable<C>
        where M : IData<C>
    {
        public B<C, M> ReadFrom(System.IO.Stream stream)
        {
            return Serializer.Deserialize<B<C, M>>(stream);
        }

        public void WriteTo(B<C, M> value, System.IO.Stream stream)
        {
            Serializer.Serialize<B<C, M>>(stream, value);
        }
    }

公共类b序列化程序：iSeries
其中C:i可比较
M:IData在哪里
{
公共B读自（System.IO.Stream）
{
返回序列化程序。反序列化（流）；
}
public void WriteTo（B值，System.IO.Stream）
{
Serializer.Serialize（流、值）；
}
}

然后我在B+树（）数据结构中使用它们，该结构定义为：

var options = new BPlusTree<C, B<C, M>>.OptionsV2(CSerializer, BSerializer);
var myTree = new BPlusTree<C, B<C, M>>(options);

var options=new BPlusTree.OptionsV2（CSerializer，BSerializer）；
var myTree=新的BPlusTree（选项）；

B+树被定义为键值对的字典。我的

键

（即

C

）是一个整数，序列化程序是

BPlusTree

库的默认序列化程序。我的

值

是一个自定义对象

B

，它使用

protobuf-net

进行序列化

---

我的问题肯定会发生，但几乎是随机发生的；始终搜索

键

，它突然开始反序列化

值

，并在第一次调用

B ReadFrom（System.IO.Stream）

时请求

TypeModel.CS

和

ProtoReader.CS

文件。我从

NuGet

获得这两个包

检查代码时，调用代码似乎假定序列化知道自己的长度；来源：

foreach (T i in items)
    _serializer.WriteTo(i, io);

---

Protobuf消息不是自终止的-google Protobuf规范定义了append===merge。因此，您需要为消息添加前缀。幸运的是，您应该能够切换到

SerializeWithLengthPrefix

和

反序列化WithLengthPrefix

。如果这不起作用，那么就值得创建一个完全可复制的示例，以便对其进行研究。

检查代码时，调用代码似乎假定序列化知道其自身的长度；来源：

foreach (T i in items)
    _serializer.WriteTo(i, io);

---

Protobuf消息不是自终止的-google Protobuf规范定义了append===merge。因此，您需要为消息添加前缀。幸运的是，您应该能够切换到

SerializeWithLengthPrefix

和

反序列化WithLengthPrefix

。如果这不起作用，那么值得将一个完全可复制的示例放在一起，以便对其进行研究。

作为解决此问题的替代方法，您还可以聚合内置Serailizer的行为：

    class BSerializer<C, M> : ISerializer<B<C, M>>
        where C : IComparable<C>
        where M : IData<C>
    {
        public B<C, M> ReadFrom(System.IO.Stream stream)
        {
            byte[] value = CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.ReadFrom(stream);
            return Serializer.Deserialize<B<C, M>>(new MemoryStream(value));
        }

        public void WriteTo(B<C, M> value, System.IO.Stream stream)
        {
            using (var memory = new MemoryStream())
            {
                Serializer.Serialize<B<C, M>>(memory, value);
                CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.WriteTo(memory.ToArray(), stream);
            }
        }
    }

类b序列化器：iSeries
其中C:i可比较
M:IData在哪里
{
公共B读自（System.IO.Stream）
{
byte[]value=CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.ReadFrom（流）；
返回序列化程序。反序列化（新内存流（值））；
}
public void WriteTo（B值，System.IO.Stream）
{
使用（var memory=new MemoryStream（））
{
Serializer.Serialize（内存、值）；
CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.WriteTo（memory.ToArray（），stream）；
}
}
}

注意：由于不必要的数据拷贝，这种方法可能会造成性能问题；然而，它可以帮助解决这个问题

另一种可能是简单地将树定义为

BPlusTree

，并提供

PrimitiveSerializer.Bytes

作为值序列化器。这将对象序列化的负担放在调用方身上，这可能是一件非常好的事情。这有两个好处：

您的对象模型不再需要是不可变的

如果对象的反序列化代价很高，那么在随机访问使用中，这可能会执行得更好

有关其他常见序列化问题和一些示例，请阅读以下文章：

---

作为解决此问题的替代方法，您还可以聚合内置Serailizer的行为：

    class BSerializer<C, M> : ISerializer<B<C, M>>
        where C : IComparable<C>
        where M : IData<C>
    {
        public B<C, M> ReadFrom(System.IO.Stream stream)
        {
            byte[] value = CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.ReadFrom(stream);
            return Serializer.Deserialize<B<C, M>>(new MemoryStream(value));
        }

        public void WriteTo(B<C, M> value, System.IO.Stream stream)
        {
            using (var memory = new MemoryStream())
            {
                Serializer.Serialize<B<C, M>>(memory, value);
                CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.WriteTo(memory.ToArray(), stream);
            }
        }
    }

类b序列化器：iSeries
其中C:i可比较
M:IData在哪里
{
公共B读自（System.IO.Stream）
{
byte[]value=CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.ReadFrom（流）；
返回序列化程序。反序列化（新内存流（值））；
}
public void WriteTo（B值，System.IO.Stream）
{
使用（var memory=new MemoryStream（））
{
Serializer.Serialize（内存、值）；
CSharpTest.Net.Serialization.PrimitiveSerializer.Bytes.WriteTo（memory.ToArray（），stream）；
}
}
}

注意：由于不必要的数据拷贝，这种方法可能会造成性能问题；然而，它可以帮助解决这个问题