How to deserialize xml with structure of abitrary nested layers of base class?

Question

let say i want to represent arithmetic expression using xml:
<?xml version="1.0" encoding="utf-8" ?>
<expr>
<add>
<num>10</num>
<num>20</num>
</add>
</expr>
and here is my classes to represent this:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Test
public abstract class Evaluable
public abstract int Eval();
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
namespace Test
[Serializable]
[XmlRoot("expr")]
public class Expr
[XmlElement]
public Evaluable Evaluable { get; set; }
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
namespace Test
[Serializable]
[XmlRoot("add")]
[XmlType("add")]
public class Add : Evaluable
[XmlElement]
public List<Evaluable> Elems { get; set; }
public override int Eval()
return Elems.Select(e => e.Eval()).Sum();
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
namespace Test
[Serializable]
[XmlRoot("num")]
[XmlType("num")]
public class Num : Evaluable
[XmlText]
public int Val { get; set; }
public override int Eval()
return Val;
but it doesn't work, and it's reasonable, since Serializer doesn't know any thing about the subclass. but how to make it work?
here is my deserialization code:
var serializer = new XmlSerializer(typeof(Expr), new[] { typeof(Add), typeof(Num) });
Expr expr = null;
using (var file = new StreamReader("expr.xml"))
expr = serializer.Deserialize(file) as Expr;

Answer 1

I think what you want is to set the XmlElement attribute on the container (Elems).
It can be done if the deserializer can be made aware of all the potential subclasses of the base class.  It's ok to put multiple XmlElement attributes on the container to let the deserializer know about the various subclasses it can deserialize.
I don't think there's a way to tell the XmlSerializer externally about new types.  I could be wrong.  [If someone shows me how to do that, I'd sure appreciate it!]   [WORKAROUND:  A potential workaround
is to create a class that contains all the potential children including the class itself and serialize that.  Seems a little like cheating.]
Here is a complete example:
[Serializable]
public class Foo
[XmlAttribute( "name" )]
public string name;
[XmlElement( "Foo", Type = typeof( Foo ) )]
[XmlElement( "Bar", Type = typeof( Bar ) )]
public List<Foo> children = new List<Foo>();
public void Dump( int level )
ShowProperties( level );
foreach( var f in children ) {
f.Dump( level + 1 );
protected virtual void ShowProperties( int level )
Console.WriteLine( "{0}{1}", new string(' ', level * 4 ), name );
[Serializable]
public class Bar : Foo
public string stuff;
protected override void ShowProperties( int level )
base.ShowProperties( level );
Console.WriteLine( "{0}{1}", new string(' ', level * 4 ), stuff );
class Program
static void Main( string[] args )
// <Foo name="A">
// <Bar name="B">
// <Foo name="D" />
// <stuff>B's Stuff</stuff>
// </Bar>
// <Bar name="C">
// <stuff>C's Stuff</stuff>
// </Bar>
// </Foo>
// A
// B
// B's Stuff
// D
// C
// C's Stuff
Foo a = new Foo() { name = "A" };
Bar b = new Bar() { name = "B", stuff="B's Stuff" };
Bar c = new Bar() { name = "C", stuff="C's Stuff" };
Foo d = new Foo() { name = "D" };
a.children.Add( b );
a.children.Add( c );
b.children.Add( d );
XmlSerializer xs = new XmlSerializer( typeof( Foo ) );
// There:
XmlSerializerNamespaces ns = new XmlSerializerNamespaces( new[] { XmlQualifiedName.Empty } );
StringBuilder sb = new StringBuilder();
using( XmlWriter xw = XmlWriter.Create( sb, new XmlWriterSettings() {
OmitXmlDeclaration = true,
Indent = true
xs.Serialize( xw, a, ns );
Console.WriteLine( sb.ToString() );
// And Back Again:
using( StringReader sr = new StringReader( sb.ToString() ) )
Foo root = (Foo)xs.Deserialize( sr );
root.Dump( 0 );