How To : Apply XmlSerialization with an Interface

[IanWright]

This is a little bit more of an advanced topic for serialization. For those who don't know what XML serialization is, then this probably isn't for you just yet. For those that do, you may have come across the problem of serializing an interface, something that you simply can't do using the standard XmlSerialization techniques. This articles looks at how to do that, although it might be a little length. Lets take the following problem:

 public interface IPoint
    {
        double X;
        double Y;
        double DistanceBetween(IPoint point);
    }
 
    public class Point2Dimensional : IPoint
    {
        public double X { get; protected set; }
        public double Y { get; protected set; }
        public virtual double DistanceBetween(IPoint point) { ... }
    }
 
    public class Point3Dimensional : Point2Dimensional
    {
        public double Z { get; protected set; }
        public override double  DistanceBetween(IPoint point) { ... }
    }
 

If we now have a class that has an IPoint.

    public class PointHolder
    {
        public IPoint Point { get; set; }
    }
 

This now means that we cannot deserialize the PointHolder class using standard serialization, because the serializer isn't clever enough to figure out the type it should be deserializing. However, it is possible to do so manually, using some custom serialization.

Firstly we want to make sure both our points can serialize / deserialize themselves. So we change our code slightly. I've ommitted the parameterless constructors, obviously you'll need to add those in.

1) Make the IPoint interface implement IXmlSerializable

 public interface IPoint : IXmlSerializable
    {
        double X;
        double Y;
        double DistanceBetween(IPoint point);
    }
 

2) Make the Point2Dimensional and Point3Dimensional implement the IXmlSerializable interface like so. I've just done the 2Dimensional class, obviously the other just adds Z to the list of things to serialize/deserialize.

   public class Point2Dimensional : IPoint
    {
        public double X { get; protected set; }
        public double Y { get; protected set; }
        public virtual double DistanceBetween(IPoint point) { ... }
 
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
 
        public void ReadXml(System.Xml.XmlReader reader)
        {
            this.X = Convert.ToDouble(reader.GetAttribute("X"));
            this.Y = Convert.ToDouble(reader.GetAttribute("Y"));
        }
 
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            writer.WriteAttributeString("X", this.X.ToString());
            writer.WriteAttributeString("Y", this.Y.ToString());
        }
    }
 

We now need to make our PointHolder implement IXmlSerializable too. This uses some extension methods which do the hardwork which we'll see in a minute. Again you'll need your parameterless constructor in there too.

    public class PointHolder : IXmlSerializable
    {
        public IPoint Point { get; set; }
 
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
 
        public void ReadXml(System.Xml.XmlReader reader)
        {
            this.Point = reader.ReadXmlSerializableElement<IPoint>("Point");
        }
 
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            writer.SaveXmlSerialiableElement("Point", this.Point);
        }
    }
 

What we do here, is basically pass in an element name, and either save or assign our Point property. Now lets take a look at the extension methods defined somewhere in a static class.

public static void SaveXmlSerialiableElement<T>(this XmlWriter writer, String elementName, T element) where T : IXmlSerializable
        {
            writer.WriteStartElement(elementName);
            writer.WriteAttributeString("TYPE", element.GetType().ToString());
            element.WriteXml(writer);
            writer.WriteEndElement();
        }
 

What's going on here? Well we write a new element with the given name, we then save the full type and namespace of that element, call through to the WriteXml on the element itself, then write the end tag. So the XML will look something like:

<Point>
<Point3Dimensional TYPE="TestApp.Point3Dimensional" x="0", y="0", z="0">
</Point>

Not too difficult. Reading is where things get interesting. There's a couple of methods that I won't go into that you'll need, I'm sure you can figure them out. The code is here:

     public static void ReadToElement(this XmlReader reader, String element)
        {
            reader.ReadToNextNode();
            while (reader.Name != element)
            {
                reader.ReadToNextNode();
            }
        }
 
        public static void ReadToNextNode(this XmlReader reader)
        {
            // Read the current item to throw it away
            reader.Read();
 
            // Keep on reading till we have read all the whitespace
            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Read();
            }
        }
 

The part that is really useful however is:

  public static T ReadXmlSerializableElement<T>(this XmlReader reader, String elementName) where T : IXmlSerializable
        {
            reader.ReadToElement(elementName);
 
            Type elementType = Type.GetType(reader.GetAttribute("TYPE"));
            T element = (T)Activator.CreateInstance(elementType);
            element.ReadXml(reader);
            return element;
        }
 

What this does, is firstly locates the element of interest. Then we read out the type of the element and create a new instance of it. We can then call through to the ReadXml on the element to initalize all it's members and return it.

This then means we can use XmlSerialization on our PointHolder regardless of the type of IPoint that it is storing within the Point property.