How should you implement Serialization? (interface/convention wise)

Question

I implement an xml serialization based on Marc's answer.

Should this be part of the class itself, ie Apple.Serialize/Deserialize?

Although Deserialize would be static in that case, as you might not have an instance to call it on.

Or should I have another class for Serialize/Deserialize? If so, these seem to be generic enough? What should I call it? AppleSerializer seems very specific.

Or something better?

Answer 1

The Serialize/Deserialize code Marc suggested is not linked to your Apple object in any way.

So I would suggest to declare them static make them a little more generic and put them in some sort of utility class. Like so:

class Util
{
  public static string SerializeToXml<T>(T o) where T: class
  {
    using (var sw = new StringWriter())
    {
      var ser = new XmlSerializer(typeof(T));

      ser.Serialize(sw, o);

      return sw.ToString();
    }
  }

  public static T DeserializeFromXml<T>(string xml) where T: class
  {
    using (var sr = new StringReader(xml))
    {
      var ser = new XmlSerializer(typeof(T))

      return ser.Deserialize(sr) as T;
    }
  }
}

Answer 2

One flaw of the technique proposed by Yannick M. is that it ties you to a particular implementation of XML Serialization. At the very least, serialization should be a virtual instance operation, so that it may be overridden by derived classes.

Also, do not start off using the XML Serializer. Use the Data Contract serializer instead. It is more efficient and faster, at the cost of not allowing you to specify the exact structure of the generated XML (which you may not need to do at all).