XmlSerializer.Deserialize为子类（不是数组）

Question

So this has had me stumped for hours... I have an xml structure that looks like this:

<custom>
  <priceLower>999999</priceLower>
  <priceUpper>1000001</priceUpper>
  <investment>true</investment>
  <offtheplan>false</offtheplan>
  <office>
    <name>Melbourne Office</name>
    <officeName>Head Office</officeName>
    ... more elements removed
  </office>
</custom>

In my application I have a Custom class, which deserializes from the above xml fine, defined as follows:

    [Serializable]
public class Custom : BaseEntity, IDataModel
{
    [XmlElement("investment")]
    public string Investment { get; set; }
    [XmlElement("offtheplan")]
    public string Offtheplan { get; set; }
    [XmlElement("priceLower")]
    public Decimal? PriceLower { get; set; }
    [XmlElement("priceUpper")]
    public Decimal? PriceUpper { get; set; }
    [XmlElement("office")]
    public Office Office { get; set; }

And my Office Object defined as follows:

    [Serializable]
public class Office : BaseEntity, IDataModel
{
    // temporary for debugging purposes:
    private string _officeName;

    [XmlElement("name")]
    public string Name { get; set; }
    [XmlElement("officeName")] 
    public string OfficeName { get; set; }
    [XmlElement("addressL1")]
    public string Address1 { get; set; }
    ... more fields removed }

The Deserialize code (called by a helper class, and receives a Property Object containing A Custom object, which contains an Office object) looks like this:

            XmlSerializer s = null;
    XmlAttributeOverrides attrOverrides = null;

            /// if it's a Residential type, do it this way
            if (typeof(T) == typeof(Residential))
            {
                attrOverrides = new XmlAttributeOverrides();
                var attrs = new XmlAttributes();
                var attr = new XmlElementAttribute();
                attr.ElementName = "office";
                attr.Type = typeof(Office);
                attrs.XmlElements.Add(attr);
                attrOverrides.Add(typeof(Office), "office", attrs);
                s = new XmlSerializer(typeof(T), attrOverrides);
            }

            s = attrOverrides == null 
                ? new XmlSerializer(typeof(T)) 
                : new XmlSerializer(typeof(T), attrOverrides);

            var obj = s.Deserialize(stream);
            return (T)obj;

SO... The Custom object deserializes perfectly.. no issues there. But the office one doesn't - all it's properties always come through as null.

Is there a way to specify exactly which element in the xml tree contains the data for the Office object? i've tried moving the Office Object to sit at the same level as Custom (on the Property object) which makes more sense really, but that didn't work either - i moved it to be under Custom to match the xml structure as I can't change that, and i couldn't find a way to specify where it should get it's data from.

Another bit of weirdness I've experienced here... I have added a Serializer function, which basically creates a new XML file from the deserialized objects. I can debug all the way through to where the Serialize function is called - and if I peek inside the object getting serialized before it happens, i can see that the Office object contains only null values. But the serializer actually serializes data into my new XML file.

Here is where it gets even weirder. If i peek into the object before Serialize() is called, then it will always serialize an empty element. BUT, if i don't peek inside that object before the serialization happens, it'll serialize data into there. I have verified this a bunch of times - without fail that is the behaviour. Has anybody ever seen anything like this? Is the framework playing tricks on me, and if so whY???

UPDATE:

Just to clarify, my XML looks something like this (I only showed an exert above):

<propertyList>
  <residential>
    <custom>
      <property1>
      <office>
        <officeName>
          Office Name Here
        </officeName>
      </office>
    </custom>
  </residential>
</propertyList>

So there's a few levels of nesting there, which i possibly the issue, though I'm thinking it's more of a VS issue.

The deserializer is working on the full XML, and deserialising down to a class structure like this:

Residential : Property : BasePropertyType

• Contains Custom Object
• Contains Office Object

Both Custom and Office objects are instantiated on the Residential object. I have tried putting the Office object on the Custom object instead (to match the xml structure) but that made no difference. Custom serializes correctly, Office does not.

Is it at all possible that the Visual Studio debugger is the red herring here. As i mentioned before, if i debug and take a look at the deserialized object, it shows it as empty, and when i then serialize it back to XML it comes through as empty. But if i don't debug and just step over without taking a look at the object, all the properties serialize correctly to the XML. It's making it kind of difficult to move on and do the rest of the data processing i need to when i can't debug what's going on there. Has anybody seen behaviour in VS like this before??

Answer 1

As to your first question, XmlSerializer can handle simple hierarchies so in your example XmlAttributeOverrides are not necessary:

    [Serializable]
    [XmlRoot("custom")]
    public class Custom 
    {
        [XmlElement("investment")]
        public string Investment { get; set; }
        [XmlElement("offtheplan")]
        public string Offtheplan { get; set; }
        [XmlElement("priceLower")]
        public Decimal? PriceLower { get; set; }
        [XmlElement("priceUpper")]
        public Decimal? PriceUpper { get; set; }
        [XmlElement("office")]
        public Office Office { get; set; }
    }

    [Serializable]
    public class Office
    {
        // temporary for debugging purposes:
        private string _officeName;

        [XmlElement("name")]
        public string Name { get; set; }
        [XmlElement("officeName")]
        public string OfficeName { get; set; }
        [XmlElement("addressL1")]
        public string Address1 { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string xml = @"<custom>
  <priceLower>999999</priceLower>
  <priceUpper>1000001</priceUpper>
  <investment>true</investment>
  <offtheplan>false</offtheplan>
  <office>
    <name>Melbourne Office</name>
    <officeName>Head Office</officeName>
  </office>
</custom>";

            XmlSerializer s = new XmlSerializer(typeof(Custom));

            // Works fine without this
            //XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
            //var attrs = new XmlAttributes();
            //var attr = new XmlElementAttribute();
            //attr.ElementName = "office";
            //attr.Type = typeof(Office);
            //attrs.XmlElements.Add(attr);
            //attrOverrides.Add(typeof(Office), "office", attrs);
            //s = new XmlSerializer(typeof(Custom), attrOverrides);

            using (StringReader reader = new StringReader(xml))
            {
                Custom c = (Custom)s.Deserialize(reader);
            }
        }
    }

Answer 2

Ahahahaha... I'm such a goof! Had a workmate run through this with me, and we found something really silly that i'd done, namely:

public string ToString()
{
    Name = null;
    OfficeName = null;
    Address1 = null;
    Address2 = null;
    City = null;
    State = null;
    Postcode = null;
    Phone = null;
    Banner = null;
    Logo = null;

    StringBuilder sb = new StringBuilder();
    sb.Append(String.Format("Name:{0} / OfficeName: {1} / Address1: {2} / Address2: {3} / City: {4} / State: {5} / Postcode: {6} / Phone: {7} / Banner: {8} / Logo: {9}",
        Name, OfficeName, Address1, Address2, City, State, Postcode, Phone, Banner, Logo));
    return sb.ToString();
}

So every time i took a look at the object in the debugger, it was calling my ToString() override, which was then nuking all the values.

Don't i feel sheepish. LOL