protobuf-net，版本控制和代理类型的最佳实践

Question

我正在尝试确定如何使用protobuf-net（Marc Gravell的实现）解决此用例。

• 我们有A类，被认为是版本1
• 类A的实例已序列化到磁盘
• 现在，我们有了类B，它被视为类A的版本2（类A有太多错误，我们必须为下一个版本创建类B）。 类A仍然存在于代码中，但仅出于遗留目的。
• 我想反序列化version：1数据（存储到磁盘）作为B类实例，并使用逻辑例程将数据从先前的A类实例转换为B类的新实例。
• B类的实例将在操作过程中序列化到磁盘。
• 应用程序应该期望反序列化类A和B的实例。

数据契约替代的概念和DataContractSerializer浮现在脑海。 目标是将version：1数据转换为新的B类结构。

一个例子：

[DataContract]
public class A {

     public A(){}

     [DataMember]
     public bool IsActive {get;set;]

     [DataMember]
     public int VersionNumber {
          get { return 1; }
          set { }
     }

     [DataMember]
     public int TimeInSeconds {get;set;}

     [DataMember]
     public string Name {get;set;}

     [DataMember]
     public CustomObject CustomObj {get;set;} //Also a DataContract

     [DataMember]
     public List<ComplexThing> ComplexThings {get;set;} //Also a DataContract
     ...
}

[DataContract]
public class B {

     public B(A a) {
          this.Enabled = a.IsActive; //Property now has a different name
          this.TimeInMilliseconds = a.TimeInSeconds * 1000; //Property requires math for correctness
          this.Name = a.Name;
          this.CustomObject2 = new CustomObject2(a.CustomObj); //Reference objects change, too
          this.ComplexThings = new List<ComplexThings>();
          this.ComplexThings.AddRange(a.ComplexThings);
          ...
     }

     public B(){}

     [DataMember]
     public bool Enabled {get;set;]

     [DataMember]
     public int Version {
          get { return 2; }
          set { }
     }

     [DataMember]
     public double TimeInMilliseconds {get;set;}

     [DataMember]
     public string Name {get;set;}

     [DataMember]
     public CustomObject2 CustomObject {get;set;} //Also a DataContract

     [DataMember]
     public List<ComplexThing> ComplexThings {get;set;} //Also a DataContract
     ...
}

A类是我们对象的第一次迭代，并且正在积极使用中。 数据以v1格式存在，使用A类进行序列化。

在意识到我们的方法的错误之后，我们创建了一个称为类B的新结构。A和B之间的变化太多，我们认为创建B相对于适应原始的类A更好。

但是我们的应用程序已经存在，并且使用A类来序列化数据。 我们已经准备好将更改推广到世界各地，但是我们必须首先反序列化在版本1下创建的数据（使用A类）并将其实例化为B类。数据足够重要，我们不能仅仅假设类中使用默认值B用于丢失数据，但是我们必须将数据从A类实例过渡到B类。一旦有了B类实例，应用程序将再次以B类格式（版本2）对数据进行序列化。

我们假设将来将对类B进行修改，并且我们希望能够迭代到版本3，也许会在新的类“ C”中进行迭代。 我们有两个目标：处理已经存在的数据，并准备我们的对象以备将来迁移。

现有的“转换”属性（OnSerializing / OnSerialized，OnDeserializing / OnDeserialized等）不提供对先前数据的访问。

在这种情况下使用protobuf-net的预期做法是什么？

Answer 1

对; 看着他们，您确实已经完全改变了合同。 我知道没有基于合约的序列化器会为此而爱你，而protobuf-net也不例外。 如果已经有根节点，则可以执行以下操作（以伪代码）：

[Contract]
class Wrapper {
    [Member] public A A {get;set;}
    [Member] public B B {get;set;}
    [Member] public C C {get;set;}
}

然后选择A / B / C中的任何一个都不为空，也许在它们之间添加一些转换运算符。 但是，如果您在旧数据中仅包含裸露的A，则将变得很难。 我可以想到两种方法：

• 添加许多垫片属性以实现兼容性； 不太容易维护，我不推荐
• 嗅探Version作为第一步，并告诉序列化程序期望什么。

例如，您可以这样做：

int version = -1;
using(var reader = new ProtoReader(inputStream)) {
    while(reader.ReadFieldHeader() > 0) {
        const int VERSION_FIELD_NUMBER = /* todo */;
        if(reader.FieldNumber == VERSION_FIELD_NUMBER) {
            version = reader.ReadInt32();
            // optional short-circuit; we're not expecting 2 Version numbers
            break;
        } else {
            reader.SkipField();
        }
    }
}
inputStream.Position = 0; // rewind before deserializing

现在，您可以使用序列化器，告诉它序列化为哪个version 。 通过通用Serializer.Deserialize<T> API，或通过两个非通用API（ Serializer.NonGeneric.Deserialize或RuntimeTypeModel.Default.Deserialize的Type实例-两种方式都可以到达同一位置；实际上通用还是非通用最方便）。

然后，您将需要A / B / C之间A一些转换代码-通过您自己的自定义运算符/方法或通过自动映射器之类的东西。

如果您不希望出现任何ProtoReader代码，也可以这样做：

[DataContract]
class VersionStub {
    [DataMember(Order=VERSION_FIELD_NUMBER)]
    public int Version {get;set;}
}

并运行Deserialize<VersionStub> ，这将使您可以访问Version ，然后可以使用该Version进行特定于类型的反序列化； 这里的主要区别是ProtoReader代码允许您在拥有版本号后立即短路。

Answer 2

我没有预期的实践，但这就是我要做的。

鉴于您仍然有权访问V1类，请在提供V2实例的V1类上添加一个属性。

在您的V1的ProtoAfterDeserialization ，创建一个V2的实例，并看到它是一个迁移，我建议您在所需的内容之间进行手动转移（或者如果不太难，请尝试Merge YMMV）。

同样，在ProtoBeforeSerialization抛出某种形式的异常，以便您不再尝试写出旧的异常。

编辑：使用这些示例（VB代码）

<ProtoBeforeSerialization()>
Private Sub BeforeSerialisaton()

End Sub

<ProtoAfterSerialization()>
Private Sub AfterSerialisaton()

End Sub

<ProtoBeforeDeserialization()>
Private Sub BeforeDeserialisation()

End Sub

<ProtoAfterDeserialization()>
Private Sub AfterDeserialisation()

End Sub

看完您的示例后，我希望这能够满足您的尝试。 Class1是您加载/转换的方式。

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

public class Class1
{
    public Class1()
    {
        using (FileStream fs = new FileStream("c:\\formatADataFile.dat",
               FileMode.Open, FileAccess.Read))
        {
            A oldA = Serializer.Deserialize<A>(fs);
            B newB = oldA.ConvertedToB;
        }
    }
}


[ProtoContract()]
public class B
{

    public B(A a)
    {
        //Property now has a different name
        this.Enabled = a.IsActive; 
        //Property requires math for correctness
        this.TimeInMilliseconds = a.TimeInSeconds * 1000; 
        this.Name = a.Name;
        //Reference objects change, too
        this.CustomObject2 = new CustomObject2(a.CustomObj); 
        this.ComplexThings = new List<ComplexThings>();
        this.ComplexThings.AddRange(a.ComplexThings);
        //...
    }

    public B() { }

    //[DataMember]
    [ProtoMember(1)]
    public bool Enabled { get; set; }

    //[DataMember]
    public int Version
    {
        get { return 2; }
        private set { }
    }

    [ProtoMember(2)]
    public double TimeInMilliseconds { get; set; }

    [ProtoMember(3)]
    public string Name { get; set; }

    [ProtoMember(4)]
    public CustomObject2 CustomObject { get; set; } //Also a DataContract

    [ProtoMember(5)]
    public List<ComplexThing> ComplexThings { get; set; } //Also a DataContract

    ///...
}

[ProtoContract()]
public class CustomObject2
{
    public CustomObject2()
    {
        Something = string.Empty;
    }

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


[ProtoContract()]
public class A
{

    public A()
    {
        mBConvert = new B();
    }

    [ProtoMember(1)]
    public bool IsActive { get; set; }

    [ProtoMember(2)]
    public int VersionNumber
    {
        get { return 1; }
        private set { }
    }

    [ProtoBeforeSerialization()]
    private void NoMoreSavesForA()
    {
        throw new System.InvalidOperationException("Do Not Save A");
    }

    private B mBConvert;

    [ProtoAfterDeserialization()]
    private void TranslateToB()
    {
        mBConvert = new B(this);
    }

    public B ConvertedToB
    {
        get
        {
            return mBConvert;
        }
    }



    [ProtoMember(3)]
    public int TimeInSeconds { get; set; }

    [ProtoMember(4)]
    public string Name { get; set; }

    [ProtoMember(5)]
    public CustomObject CustomObj { get; set; } //Also a DataContract

    [ProtoMember(6)]
    public List<ComplexThing> ComplexThings { get; set; } //Also a DataContract
    //...
}

[ProtoContract()]
public class CustomObject
{
    public CustomObject()
    {

    }
    [ProtoMember(1)]
    public int Something { get; set; }
}

[ProtoContract()]
public class ComplexThing
{
    public ComplexThing()
    {

    }
    [ProtoMember(1)]
    public int SomeOtherThing { get; set; }
}