在C＃序列化器中继承多个属性

Question

I am working on serializing a class that has left a right properties which are of a base type.

[Serializable]    
public class MyClass{
    public BaseChild Left {get;set;}
    public BaseChild Right {get;set;}
}

If I serialize this, I get an xml that has something like this:

<Left p7:type="InherrittedChild" xmlns:p7=blabla>
   <Property />
</Left>

Are there some options I can set on those properties to make the xml look like this:

<Left>
   <InherittedChild>
       <Property />
   </InherittedChild>
</Left>

Since I have two properties that are the same type, I can't just add the [XmlInclude(typeof(child))] since that would render an ambiguous xml.

Answer 1

Really tricky ... XmlSerialization is not polymorphic so your XML usually provides a flattened version of your object hierarchie. I see two possible implementations. The first exposes the base property as another name (see "ConcreteChild"). The other implements IXmlSerialization (see "ConcreteChild2") so that you can write your custom nesting of properties.

// Base Class
[Serializable]
[XmlInclude(typeof(ConcreteChild))]
public class BaseChild
{
    public BaseChild()
    {
        ChildName = "Base";
    }

    public String ChildName { get; set; }
}

// Exposing Parent Property
[Serializable]
public class ConcreteChild : BaseChild
{
    public new String ChildName { get; set; }

    public String BaseChildName { 
        get
        {
            return ((BaseChild) this).ChildName;
        }

        set
        {
            ((BaseChild)this).ChildName = value;
        }
    }
}


// Writing Custung Serializable
[Serializable]
public class ConcreteChild2 : BaseChild, IXmlSerializable
{
    public new String ChildName { get; set; }

    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(XmlReader reader)
    {
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteStartElement("InherittedChild");
        writer.WriteElementString("ConcreteChildName", ChildName);
        writer.WriteEndElement();

        // Since BaseChild does not implement IXmlSerializable
        // we cannot use base.WriteXml(writer);
        writer.WriteElementString("BaseChildName", ((BaseChild) this).ChildName);
    }
}

[XmlInclude(typeof(ConcreteChild))]
[XmlInclude(typeof(ConcreteChild2))]
[Serializable]
public class MyClass
{
    public BaseChild Left { get; set; }

    [XmlElement("ConcreteChild2", typeof(ConcreteChild2))]  // does not work without !!!
    public BaseChild Right { get; set; }

}

Result: You can see both serializations in the MyClass structure

<?xml version="1.0" encoding="utf-16"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Left xsi:type="ConcreteChild">
    <ChildName>Left</ChildName>
    <BaseChildName>Base</BaseChildName>
  </Left>
  <ConcreteChild2>
    <InherittedChild>
      <ConcreteChildName>Right</ConcreteChildName>
    </InherittedChild>
    <BaseChildName>Base</BaseChildName>
  </ConcreteChild2>
</MyClass>

Serialization

var mc = new MyClass();
mc.Left = new ConcreteChild { ChildName = "Left"};
mc.Right = new ConcreteChild2 { ChildName = "Right" };
StringWriter textWriter = new StringWriter();
XmlSerializer xmlSerializer = new XmlSerializer(mc.GetType());
xmlSerializer.Serialize(textWriter, mc);
var s = textWriter.ToString();