C#

<?xml version="1.0" encoding="utf-8"?>
<orchestra>
  <bloweythingy name="flute" reed="false"/>
  <bloweythingy name="oboe" reed="true"/>
  <hitythingy name="tympani" keys="false"/>
  <hitythingy name="piano" keys="true"/>
</orchestra>

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace Deserialising
{
    class ExampleA
    {
        static void Main(string[] args)
        {
            XmlSerializer iniSerializer = new XmlSerializer(typeof(Orchestra));
            TextReader iniReader = new StreamReader("C:\\Temp\\ExampleOrchestra.xml");
            try
            {
                Orchestra DuchyOfGrandFenwickPhilharmonic = (Orchestra)iniSerializer.Deserialize(iniReader);
            }
            catch (Exception ex)
            {
                while (ex != null)
                {
                    Console.WriteLine(ex.Message);
                    ex = ex.InnerException;
                }
                Console.ReadKey();
            }
            iniReader.Close();
        }
    }

    [XmlRoot("orchestra")]
    public class Orchestra : IXmlSerializable
    {
        /// <summary>
        /// Records the xml element tags used to create each of instrument types.
        /// This is done to avoid having to decorate each class with an XmlElement
        /// tag (a requirement of the real application - any decoration seen in this
        /// example is only there to simplify the example).
        /// </summary>
        private Dictionary<string, Type> RegisteredElements;

        private XmlAttributeOverrides instrumentXmlOverrides;

        public Orchestra()
        {
            this.RegisteredElements = new Dictionary<string, Type>();
            this.Compliment = new List<Instrument>();

            // Create a registry of xml tags and which classes to use to deserialise them.
            // In the real application, the registry is populated by other methods in other 
            // classes.
            RegisteredElements.Add("bloweythingy", typeof(Woodwind));
            RegisteredElements.Add("hitythingy", typeof(Percussion));

            // Use the registry to create the rules describing how to deserialise the 
            // various silly tag names found in the XML into classes with sensible names.
            instrumentXmlOverrides = new XmlAttributeOverrides();
            foreach (KeyValuePair<string, Type> kvp in RegisteredElements)
            {
                // create the deserialisation override for this 
                XmlElementAttribute xea = new XmlElementAttribute(kvp.Key, kvp.Value);
                XmlAttributes xa = new XmlAttributes();
                xa.XmlElements.Add(xea);

                // variation A:
                instrumentXmlOverrides.Add(typeof(Instrument), kvp.Value.Name, xa);
                // variation B:
                //instrumentXmlOverrides.Add(typeof(Instrument), kvp.Key, xa);
                // variation C:
                //instrumentXmlOverrides.Add(kvp.Value, kvp.Value.Name, xa);
            }
        }

        /// <summary>Holds all the instruments in this Orchestra</summary>
        public List<Instrument> Compliment { get; set; }

        #region IXmlSerializable methods
        public XmlSchema GetSchema() { return null; }  // not interested in schemas

        public void ReadXml(XmlReader reader)
        {

            reader.ReadStartElement();
            while (reader.NodeType != XmlNodeType.EndElement)
            {
                // subvariation: 1
                XmlSerializer ts = new XmlSerializer(typeof(Instrument), instrumentXmlOverrides);

                // subvariation: 2
                //Type elemType = RegisteredElements[reader.Name];
                //XmlSerializer ts = new XmlSerializer(elemType, instrumentXmlOverrides);

                this.Compliment.Add((Instrument)(ts.Deserialize(reader)));
            }
            reader.ReadEndElement();
        }

        public void WriteXml(XmlWriter writer) { }  // not interested in serialising
        #endregion
    }

    public class Instrument
    {
        [XmlAttribute("name")]
        public string Name { get; set; }
    }

    public class Woodwind : Instrument
    {
        [XmlAttribute("reed")]
        public bool hasReed { get; set; }
    }

    public class Percussion : Instrument
    {
        [XmlAttribute("keys")]
        public bool hasKeys { get; set; }
    }
}

<small>when kvp = {"bloweything", typeof(Woodwind)}:</small>
  XmlElementAttribute xea = new XmlElementAttribute(kvp.Key, kvp.Value); 
    <small>= associate <bloweything> tags with Woodwind classes</small>
  XmlAttributes xa = new XmlAttributes(); 
  xa.XmlElements.Add(xea);  
    <small>= we now have a new rule: <bloweythingy> becomes Woodwind (deserialising) and Woodwinds are written as <bloweythingy> (serialising)</small>

  instrumentXmlOverrides.Add(typeof(Instrument), kvp.Value.Name, xa); 
    <small>= when told to deserialise an Instrument [parm 1], if you run across a <bloweythingy> tag [parm2] apply the rules in xa (deserialise the <bloweythingy> tags into Woodwinds) [parm 3]</small>
  
  ...

<small>when reader.Name = "bloweythingy":</small>
  XmlSerializer ts = new XmlSerializer(typeof(Instrument), instrumentXmlOverrides);
    <small>= I'm telling you to deserialise an Instrument using the above stated rules, so you should turn the <bloweythingy> into a Woodwind</small>

  this.Compliment.Add((Instrument)(ts.Deserialize(reader)));
    <small>= @#$%# - WHY WON'T .NET LISTEN TO ME?!?!?  I HATE COMPUTERS</small>