.NET 可序列化实体

Question

我需要使我的所有实体都可序列化。所以我在想一个带有备份和恢复方法的 BaseEntity。但是在恢复中我不能用保存的对象覆盖对象，因为this 是只读的。

获取可序列化实体的任何解决方案或其他方式？

我的代码：

internal class BaseEntity
{
    private MemoryStream ms = new MemoryStream();
    private BinaryFormatter bf = new BinaryFormatter();

    public void Backup()
    {
        bf.Serialize(ms, this);
    }

    public void Restore()
    {
        this = (BaseEntity)bf.Deserialize(ms);
    }
}

Answer 1

更常见的模式是不让对象自行序列化/反序列化；而是使用外部序列化程序：

var serializer = new DataContractJsonSerializer(typeof(YourClass));
var stream = ...;
YourClass yourObj = ...;

serializer.WriteObject(stream, yourObj);

var restoredObj = serializer.ReadObject(stream);

Answer 2

编辑：序列化的一种工作方式是使用 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter（或 IFormatter 的其他实现）。要序列化对象，您需要传递对象和流。要反序列化对象，请传递一个流（位于序列化数据的开头），它会返回序列化对象及其所有依赖项。

public static class EntityBackupServices
{
   public static MemoryStream Backup (BaseEntity entity)
   {
      var ms = new MemoryStream();
      Serialize (ms, entity);
      ms.Position = 0;
      return ms;
   }
   public static void Serialize (Stream stream, BaseEntity entity)
   {
      var binaryFormatter = new BinaryFormatter();
      binaryFormatter.Serialize (stream, entity);
   }
   public static BaseEntity Restore (Stream stream)
   {
      var binaryFormatter = new BinaryFormatter();
      var entity = (BaseEntity) binaryFormatter.Deserialize (stream);
      return entity;
   }
}

格式化程序不做的一件事（尽管 FormatterServices 类使之成为可能）是修改现有对象。因此，您可能不希望有一个名为 Deserialize 的实例方法。你不能这样做：new LionEntity().Deserialize () 替换现有实例的字段。

注意：您需要将Serializable 放在所有类型上。任何不能被序列化的字段（因为它要么不是结构，要么没有被标记为 [Serializable] 将需要用NonSerialized 标记。

// A test object that needs to be serialized.
[Serializable()]        
public class BaseEntity
{
    public int member1;
    public string member2;
    public string member3;
    public double member4;

    // A field that is not serialized.
    [NonSerialized()] public MyRuntimeType memberThatIsNotSerializable; 

    public TestSimpleObject()
    {
        member1 = 11;
        member2 = "hello";
        member3 = "hello";
        member4 = 3.14159265;
        memberThatIsNotSerializable = new Form ();
    }

    public MemoryStream Backup ()
    {
       return EntityBackupServices.Backup (this);
    }
}

编辑： 我提到的方式是一种相当标准且被接受的方式。如果您想冒险进入 hackdom，您可以按照我提到的方式反序列化对象，然后使用反射将现有对象上的每个字段设置为反序列化对象的值。

public class BaseEntity
{
   void Restore(Stream stream)
   {
      object deserialized = EntityBackupServices.RestoreDeserialize(stream);//As listed above
      if (deserialized.GetType () != this.GetType ())
         throw new Exception();
      foreach (FieldInfo fi in GetType().GetFields())
      {
         fi.SetValue(this, fi.GetValue (deserialized));
      }
   }
}

Answer 3

public IEntidadBase Restore()
{
    return (IEntidadBase)bf.Deserialize(ms);
}

@jacklondon 你会如何处理 EntitySerializer 方法？

您可以使用http://www.servicestack.net/ StackService.Text 模块对干净的实体进行序列化处理。您不需要任何 ms 方式的属性（可序列化/数据契约）。

 public class EntityFoo
    {
        public string Bar { get; set; }

        public EntityFoo (string bar)
        {
            Bar = bar;
        }
    }

    public class EntityDumper //and the EntitySerializer
    {
        public static string Dump<T> (T entity)
        {
            return new TypeSerializer<T> ().SerializeToString (entity);
        }

        public static T LoadBack<T> (string dump)
        {
            return new TypeSerializer<T> ().DeserializeFromString (dump);
        }
    }



    public class dump_usage
    {
        public void start ()
        {
            string dump = EntityDumper.Dump (new EntityFoo ("Space"));

            EntityFoo loaded = EntityDumper.LoadBack<EntityFoo> (dump);
            Debug.Assert (loaded.Bar == "Space");
        }
    }

Answer 4

我不一定推荐这样做，但这里有一种模式可以让对象使用创建新实例的序列化来保持和恢复其自身状态：

public sealed class MyClass
{
    private Data _data = new Data();

    //Properties go here (access the public fields on _data)

    public void Backup()
    {
        //Serialize Data
    }

    public void Restore()
    {
        //Deserialize Data and set new instance
    }

    private sealed class Data
    {
        //Public fields go here (they're private externally [because Data is private], but public to MyClass.)
    }
}

请注意，这仅在您的序列化程序支持非公共类时才有效。最坏的情况是，您必须将嵌套类公开，这很丑陋，但不会损害封装（因为实例是私有的）。