.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 ()，它会替换现有实例的字段。

注意：您需要将Serialized< /a> 覆盖所有类型。任何无法序列化的字段（因为它不是结构体，或者未标记为 [Serializable]）都需要用 非序列化。

// 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.)
    }
}

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