Сериализуемая сущность .NET

Изменить: один из способов сериализации - использовать 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);
    }
}

Изменить: способ, о котором я упоминал, является довольно стандартным и приемлемым способом. Если вы хотите заняться хакерством, вы можете десериализовать объект, как я уже упоминал, а затем использовать отражение, чтобы установить каждое поле в вашем существующем объекте на значение десериализованного объекта.

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));
      }
   }
}

Более распространенный шаблон - не возлагать на объекты ответственность за сериализацию / десериализацию самих себя; скорее используйте внешний сериализатор:

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

serializer.WriteObject(stream, yourObj);

var restoredObj = serializer.ReadObject(stream);

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

@jacklondon, как бы вы использовали методы EntitySerializer?

Вы можете выполнить процесс сериализации с помощью модуля http://www.servicestack.net/ StackService.Text для чистых объектов. Вам не нужен какой-либо атрибут (сериализуемый / datacontract) в формате 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");
        }
    }

Я не обязательно рекомендую это, но вот один шаблон для объекта, который может сохраняться и восстанавливать свое собственное состояние с помощью сериализации, которая создает новые экземпляры:

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

Обратите внимание, что это работает, только если ваш сериализатор поддерживает закрытые классы. В худшем случае вам нужно сделать вложенный класс общедоступным, что некрасиво, но не повредит инкапсуляции (поскольку экземпляр является частным).