Protobuf net延迟流式反序列化字段

总体目标：在反序列化时跳过一个很长的字段，在访问该字段时直接从流中读取元素，而不加载整个字段。

示例类正在序列化/反序列化的对象是FatPropertyClass。

[ProtoContract]
public class FatPropertyClass
{
    [ProtoMember(1)]
    private int smallProperty;
    [ProtoMember(2)]
    private FatArray2<int> fatProperty;
    [ProtoMember(3)]
    private int[] array;
    public FatPropertyClass()
    {
    }
    public FatPropertyClass(int sp, int[] fp)
    {
        smallProperty = sp;
        fatProperty = new FatArray<int>(fp);
    }
    public int SmallProperty
    {
        get { return smallProperty; }
        set { smallProperty = value; }
    }
    public FatArray<int> FatProperty
    {
        get { return fatProperty; }
        set { fatProperty = value; }
    }
    public int[] Array
    {
        get { return array; }
        set { array = value; }
    }
}

[ProtoContract]
public class FatArray2<T>
{
    [ProtoMember(1, DataFormat = DataFormat.FixedSize)]
    private T[] array;
    private Stream sourceStream;
    private long position;
    public FatArray2()
    {
    }
    public FatArray2(T[] array)
    {
        this.array = new T[array.Length];
        Array.Copy(array, this.array, array.Length);
    }

    [ProtoBeforeDeserialization]
    private void BeforeDeserialize(SerializationContext context)
    {
        position = ((Stream)context.Context).Position;
    }
    public T this[int index]
    {
        get
        {
            // logic to get the relevant index from the stream.
            return default(T);
        }
        set
        {
            // only relevant when full array is available for example.
        }
    }
}

我可以反序列化为：FatPropertyClass d = model.Deserialize(fileStream, null, typeof(FatPropertyClass), new SerializationContext() {Context = fileStream}) as FatPropertyClass;，其中model可以是例如：

    RuntimeTypeModel model = RuntimeTypeModel.Create();
    MetaType mt = model.Add(typeof(FatPropertyClass), false);
    mt.AddField(1, "smallProperty");
    mt.AddField(2, "fatProperty");
    mt.AddField(3, "array");
    MetaType mtFat = model.Add(typeof(FatArray<int>), false);

这将跳过FatArray<T>中array的反序列化。但是，稍后我需要从该数组中读取随机元素。我尝试过的一件事是在FatArray2<T>的BeforeDeserialize(SerializationContext context)方法中记住反序列化之前的流位置。如上述代码：position = ((Stream)context.Context).Position;。然而，这似乎永远是潮流的终点。

我如何记住FatProperty2开始的流位置，以及如何在随机索引中读取它？

注意：FatArray2<T>中的参数T可以是用[ProtoContract]标记的其他类型，而不仅仅是基元。此外，在对象图的不同深度处可能存在FatProperty2<T>类型的多个属性。

方法2：在序列化包含对象之后，序列化字段FatProperty2<T>。因此，用长度前缀序列化FatPropertyClass，然后用长度前缀串行化它包含的所有胖数组。用一个属性标记所有这些胖数组属性，在反序列化时，我们可以记住每个属性的流位置。

那么问题是我们如何从中读取原语呢？这对于使用T item = Serializer.DeserializeItems<T>(sourceStream, PrefixStyle.Base128, Serializer.ListItemTag).Skip(index).Take(1).ToArray();来获取索引index处的项的类来说是可以的。但这对基元是如何工作的呢？基元数组似乎无法使用DeserializeItems进行反序列化。

带LINQ的DeserializeItems可以这样使用吗？它会像我假设的那样（在内部跳过流到正确的元素——最坏的情况是读取每个长度前缀并跳过它）吗？

谨致问候，Iulian