Cannot deserialize XML into a list using XML Deserializer

Question

This follows on from my previous question Serialize list of interfaces using XML Serialization

    public class MeterWalkOrder
    {
        public MeterWalkOrder()
        {
            Meters = new List<IMeter>();
        }

        public String Name { get; set; }

        [XmlIgnore]
        public List<IMeter> Meters { get; set; }

        [XmlArrayItem(ElementName = "Meter")]
        [XmlArray(ElementName = "Meters")]
        public List<Meter> SerializableMeters
        {
            get
            {
                return Meters.Cast<Meter>().ToList();
            }
            set
            {
                Meters = new List<IMeter>(value);                
            }
        }
    }

     public interface IMeter {
       int MeterID { get; set; }
     }

     public class Meter : IMeter {
         public int MeterID { get; set; }
         public string SerialNumber { get; set; }
     }
}

I am using the extension method below to deserialize the XML back into my object (ideally I would prefer the extension method to be off of object, but I not too comfortable with extension methods so I have left like this for now)...

public static class SerializationExtensions
{

    public static T LoadFromXML<T>(this string xmlString)
    {
        T returnValue = default(T);

        XmlSerializer serial = new XmlSerializer(typeof(T));
        StringReader reader = new StringReader(xmlString);
        object result = serial.Deserialize(reader);

        if (result != null && result is T)
        {
            returnValue = ((T)result);
        }

        reader.Close();

        return returnValue;
    }

....However, when I give the XML below....

<?xml version="1.0"?>
<MeterWalkOrder xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Red Route</Name>
  <Meters>
    <Meter>
      <MeterID>1</MeterID>
      <SerialNumber>12345</SerialNumber>
    </Meter>
    <Meter>
      <MeterID>2</MeterID>
      <SerialNumber>SE</SerialNumber>
    </Meter>
  </Meters>
</MeterWalkOrder>

No meters are populated?

Does anyone know what could cause this problem? The XML is valid and SerializeableMeters is simply a property that reads from and writes to Meters but casting it as a concrete class due to the known issues with using interfaces in serialization

Answer 1

The problem is that XmlSerializer deserializes a property referring to a class implementing IList<T> in the following way:

1. It calls the getter to get the list. If null, it allocates a list and sets it via the setter. It holds onto the list in some local variable while reading it.

2. It deserializes each list element, and adds it to the list it is holding.

3. And that's it. It never calls the containing class's list property setter afterwards.

You can verify this by replacing your List<Meter> with an ObservableCollection<Meter>, and setting a debug listener for when the collection changes:

    [XmlArrayItem(ElementName = "Meter")]
    [XmlArray(ElementName = "Meters")]
    public ObservableCollection<Meter> SerializableMeters
    {
        get
        {
            Debug.WriteLine("Returning proxy SerializableMeters");
            var list = new ObservableCollection<Meter>(Meters.Cast<Meter>());
            list.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(list_CollectionChanged);
            return list;
        }
        set
        {
            Debug.WriteLine("Setting proxy SerializableMeters");
            Meters = new List<IMeter>(value.Cast<IMeter>());
        }
    }

    static void list_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        var collection = (IList<Meter>)sender;
        Debug.WriteLine("Proxy collection changed to include : ");
        foreach (var item in collection)
            Debug.WriteLine("   " + item.ToString());
    } 

Doing so, you'll see the following debug output:

Returning proxy SerializableMeters
Returning proxy SerializableMeters
Returning proxy SerializableMeters
Returning proxy SerializableMeters
Proxy collection changed to include : 
   Meter: 1, 12345
Proxy collection changed to include : 
   Meter: 1, 12345
   Meter: 2, SE

As you can see, the list is never set back.

Luckily, there's an easy alternative. If you return a proxy array instead of a proxy List, XmlSerializer will allocate the array itself, populate it, and set it via the setter -- which is just what you want!

    [XmlArrayItem(ElementName = "Meter")]
    [XmlArray(ElementName = "Meters")]
    public Meter [] SerializableMeters
    {
        get
        {
            return Meters.Cast<Meter>().ToArray();
        }
        set
        {
            Meters = new List<IMeter>(value.Cast<IMeter>());
        }
    }

And then later

    var meters = xml.LoadFromXML<MeterWalkOrder>();
    Debug.Assert(meters.Meters.Count == 2); // No assert.