(How)
C^# You Are - 1 July 2007

Serialization is the theme this week.

1. What is serialization in .NET?  Answer

   Serialization, in .NET, is the process of converting an in-memory object to a format that can be stored in persistent storage or sent to another computer.  Serialization is often used for storing object on disk for later retrieval (such as in a drawing program).  Serialization is also used for sending objects across processes or machines.  Deserialization is the process of converting some formatted data back into an in-memory object.

   Binary serialization converts the object to a binary format suitable for transfer.  It is used for fast communication with another .NET component.  Remoting is a good example where binary serialization is used. 

   XML serialization converts the object to an XML format.  It is slower and larger than binary serialization but it allows for non .NET components to be used to receive the object.  Serializing an object for transfer in a web service would be an example of XML serialization.

2. What does the SerializableAttribute attribute do?  Answer

   This attribute identifies an object that supports serialization.  During serialization all objects must have this attribute in order for serialization to succeed.  This attribute does not provide any control over the serialization process.  The ISerializable interface is used to control how objects are serialized and deserialized.  In v2 the IXmlSerializable interface was exposed.  This interface is used strictly with XmlSerializer to allow better control over the serialization process.

   Care must be taken when serializing objects.  Interdependencies between objects can be difficult to serialize properly.  For example if a library class maintains a list of authors and a list of books AND each book contains a reference to its author then, without additional code, there is no way to serialize out each author just once and deserialize the data back in later.  Instead each book would serialize its own copy of the author, even though they are the same, and the list of authors would also be serialized.  This is where the ISerializable interface would come in handy.

   Normally the fields and possibly the properties in a type are serialized out.  Use the NonSerialized attribute on a field to exclude it from serialization.  The ISerializable interface can override this behavior.  The XML serializer only serializes public fields and properties while the binary serializer serializes all fields and properties.

3. How do you serialize an object?  Answer

   You must do three things to serialize an object.  Firstly you must identify the type of serialization you are going to use.  By default binary and XML formats are supported.  Once you've identified the serialization format you must create an instance of the serializer and then tell it what type you will serialize.  This allows the serializer to verify that all fields can be serialized properly and, if necessary, identify whether the type will handle its own serialization.  Finally you must give the serializer the object to be serialized.  The serializer requires, in addition to the object to serialize, the stream to write the data to.

   A word of caution about performance.  Serialization requires that temporary code generation occur.  Each time you create an instance of the XmlSerializer with a new type code generation occurs.  For optimization purposes this code is cached until the process terminates.  However the next time you run the process it will do it again.

   Here is a code sample.

   public void SerializeData ( Stream writer, object data )
   {
      XmlSerializer serializer = new XmlSerializer(typeof(data));
   
      serializer.Serialize(writer, data);  
   }

4. How do you deserialize an object?  Answer

   Deserialization works basically the same way.  The only difference is that it requires the stream to read from.  When the DeSerialize method is called it will return the object deserialized from the stream.

   public object DeserializeData ( Stream reader, Type dataType )
   {
      XmlSerializer serializer = new XmlSerializer(dataType);
   
      return serializer.Deserialize(reader);
   }

5. How do you serialize interface fields?  Answer

   You can not technically.  The problem isn't serialization as much as it deserialization.  Since an interface is an abstraction the deserializer can not simply create an instance of the interface.  The same problem occurs with abstract classes as well.

   Given the following code serialization will work properly.

   public interface IItem
   { 
      string Name { get; set; }
   }
   
   [Serializable]
   public class Item : IItem
   { 
      private string m_strName;
   
      public string Name
      {
         get { return m_strName; }
         set { m_strName = value; }
      }
   }
   
   [Serializable]
   public class Book : Item
   { }
   
   class Program
   {
      static void Main ( string[] args )
      {
         Item item = new Book();    // #1
         item.Name = "Hello";
     
         using (StreamWriter sw = new StreamWriter(@"c:\temp\test.xml"))
         {
            XmlSerializer serializer = new XmlSerializer(typeof(Item));  // #2
            serializer.Serialize(sw, item);
         };
      }
   }
   

   If line 2 is changed to IItem then serialization will fail with an error saying that the interface can not be serialized.  As it does not have an implementation there is nothing meaningful that can be generated for it.  You might think that the serializer could simply use the type information from the object being serialized but remember that the serialization "schema" is determined by the type that you pass to the constructor.

   If Item is changed to abstract then serialization will fail because the serializer can not determine how to serialize the class.  This time we get a general error.  Since we used Item for the type in the XmlSerializer constructor that is the type that it tried to serialize.  If we had used item.GetType instead it would have worked.

   Remember that the type used in the constructor is the type that is used for serialization.  If we were to add a new property/field to Book then that data would not be serialized because we were using the Item base type.  You must be careful when serializing data using base types.

   So how do you serialize an interface?  The only real solution is to serialize the actual underlying object.  This pretty much mandates that you override ISerializable and/or IXmlSerializable.  You could expose a public property/field that holds the real type but then you are messing up the design of your class.