假设我有一个简单的类

public class Document
{
    public int Version { get; set; }
    public string Name { get; set; }
    public string Image { get; set; } // Base64 coded Bitmap object
}

现实世界的对象要复杂得多。我使用 XmlSerializer.Serialize 将实例保存到文件中。

图像中的内容是这样生成的:

byte[] result = null;
using (var image = Bitmap.FromFile(@"filename"))
using (var stream = new MemoryStream())
{
    image.Save(stream, ImageFormat.Jpeg);
    result = stream.ToArray();
}
var content = Convert.ToBase64String(result);

现在我有一个突破性的改变。 将来我想保存原始图像数据(也作为 base64)而不将其转换为 jpg。

所以我的新对象看起来像这样:

public class Document
{
    public int Version { get; set; }
    public string Name { get; set; }
    public string RawImageString { get; set; }
}

幸运的是，我已经为每个 xml 文件存储了一个版本属性(当前为 1)。对于新项目，我可以

现在我想知道是否有关于如何处理模型更改的最佳实践。 我在考虑这种方法:

• 仍然在我的类中定义一个属性ImageString，标记为已过时。
• 该属性将只有一个 setter 而没有 getter

• 如果 ImageString 已设置，我只需更新 RawImageString

  public class Document
  {
      public int Version { get; set; }
      public string Name { get; set; }
      public string RawImageString { get; set; }
      [Obsolete("Use RawImageString instead")]
      public string ImageString
      { 
          set
          {
              this.RawImageString = value; 
              this.Version = 2;
          }
      }
  }
  

这应该能很好地工作，但它需要我永远维护遗留属性(property)。我更喜欢

// depending on the version property XmlSerializer should return a 
// different Document implementation
var serializer = new XmlSerializer(typeof(IDocument));
var document = (IDocument)serializer.Deserialize(reader);

当然，我可以使用工厂方法实现这一点，但这需要两次读取。一为版本，二为具体结果。

最佳答案

最后我是这样解决的。

无论如何，Document 都是使用静态方法创建的。 现在我检查版本是否与当前版本匹配，如果不匹配则开始迁移。

    public const int CURRENT_VERSION = 2;
    public static DocumentOpen(string path)
    {
        var controller = new DocumentController();

        var item = controller.ReadXml(path);

        if (item.Version != CURRENT_VERSION)
        {
            var migrator = new DocumentMigrator(item, path);
            migrator.MigrateToLatestVersion();
        }

        return item;
    }

迁移器看起来像这样

public class DocumentMigrator
{

    private Document item;
    private String path;

    public DocumentMigrator(Documentitem, string path)
    {
        this.item = item;
        this.path = path;
    }

    public void MigrateToLatestVersion()
    {
        Migrate(Document.CURRENT_VERSION);
    }

    public void Migrate(int to)
    {
        Migrate(item.Version, to);
    }

    private void Migrate(int from, int to)
    {
        if (from < to)
        {
            while (item.Version < to)
                Up(item.Version + 1);
        }
        else if (from > to)
        {
            while (item.Version < to)
                Down(item.Version - 1);
        }
    }

    private void Down(int version)
    {
        throw new NotImplementedException();
    }

    private void Up(int version)
    {
        if (version == 2)
        {
            var stream = File.OpenRead(path);
            var serializer = new XmlSerializer(typeof(DocumentV1));
            var document = (DocumentV1)serializer.Deserialize(stream);

            this.item.RawImageString = document.ImageString;
        }
        else
        {
            throw new NotImplementedException();
        }

        this.item.Version = version;
    }

}

public class DocumentV1
{
    public string ImageString { get; set; }
}

我的想法是，我创建了一个辅助类 DocumentV1，它只包含我想要迁移的属性。这甚至可以通过使用动态或 XElement 来避免。

我执行升级并从原始类更新版本。也可以在 Down 方法中实现向后迁移，但目前不需要。

关于c# - XmlSerializer - 将 xml 文件迁移到新版本的最佳方式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22785756/