Forma correcta de implementar IXmlSerializable?

Una vez que un programador decide implementar IXmlSerializable, ¿cuáles son las reglas y las mejores prácticas para implementarlo? Escuché que GetSchema()debería regresar nully ReadXmldebería pasar al siguiente elemento antes de regresar. ¿Es esto cierto? ¿Y qué pasa si WriteXmldebería escribir un elemento raíz para el objeto o se supone que la raíz ya está escrita? ¿Cómo se deben tratar y escribir los objetos secundarios?

Aquí hay una muestra de lo que tengo ahora. Lo actualizaré a medida que obtenga buenas respuestas.

public class MyCalendar : IXmlSerializable
{
    private string _name;
    private bool _enabled;
    private Color _color;
    private List<MyEvent> _events = new List<MyEvent>();


    public XmlSchema GetSchema() { return null; }

    public void ReadXml(XmlReader reader)
    {
        if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyCalendar")
        {
            _name    = reader["Name"];
            _enabled = Boolean.Parse(reader["Enabled"]);
            _color   = Color.FromArgb(Int32.Parse(reader["Color"]));

            if (reader.ReadToDescendant("MyEvent"))
            {
                while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyEvent")
                {
                    MyEvent evt = new MyEvent();
                    evt.ReadXml(reader);
                    _events.Add(evt);
                }
            }
            reader.Read();
        }
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteAttributeString("Name",    _name);
        writer.WriteAttributeString("Enabled", _enabled.ToString());
        writer.WriteAttributeString("Color",   _color.ToArgb().ToString());

        foreach (MyEvent evt in _events)
        {
            writer.WriteStartElement("MyEvent");
            evt.WriteXml(writer);
            writer.WriteEndElement();
        }
    }
}

public class MyEvent : IXmlSerializable
{
    private string _title;
    private DateTime _start;
    private DateTime _stop;


    public XmlSchema GetSchema() { return null; }

    public void ReadXml(XmlReader reader)
    {
        if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "MyEvent")
        {
            _title = reader["Title"];
            _start = DateTime.FromBinary(Int64.Parse(reader["Start"]));
            _stop  = DateTime.FromBinary(Int64.Parse(reader["Stop"]));
            reader.Read();
        }
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteAttributeString("Title", _title);
        writer.WriteAttributeString("Start", _start.ToBinary().ToString());
        writer.WriteAttributeString("Stop",  _stop.ToBinary().ToString());
    }
}

XML de muestra correspondiente

<MyCalendar Name="Master Plan" Enabled="True" Color="-14069085">
    <MyEvent Title="Write Code" Start="-8589241828854775808" Stop="-8589241756854775808" />
    <MyEvent Title="???" Start="-8589241828854775808" Stop="-8589241756854775808" />
    <MyEvent Title="Profit!" Start="-8589247048854775808" Stop="-8589246976854775808" />
</MyCalendar>

Sí, GetSchema () debería devolver nulo .

Método IXmlSerializable.GetSchema Este método está reservado y no debe utilizarse. Al implementar la interfaz IXmlSerializable, debe devolver una referencia nula (Nothing en Visual Basic) de este método y, en su lugar, si se requiere un esquema personalizado, aplique XmlSchemaProviderAttribute a la clase.

Tanto para lectura como para escritura, el elemento objeto ya se ha escrito, por lo que no necesita agregar un elemento externo en escritura. Por ejemplo, puede comenzar a leer / escribir atributos en los dos.

Para escribir :

La implementación de WriteXml que proporcione debe escribir la representación XML del objeto. El marco escribe un elemento contenedor y posiciona al escritor XML después de su inicio. Su implementación puede escribir su contenido, incluidos los elementos secundarios. El marco luego cierra el elemento contenedor.

Y para leer :

El método ReadXml debe reconstituir su objeto utilizando la información escrita por el método WriteXml.

Cuando se llama a este método, el lector se coloca al comienzo del elemento que envuelve la información para su tipo. Es decir, justo antes de la etiqueta de inicio que indica el comienzo de un objeto serializado. Cuando este método regresa, debe haber leído todo el elemento de principio a fin, incluido todo su contenido. A diferencia del método WriteXml, el marco no maneja el elemento contenedor automáticamente. Su implementación debe hacerlo. El incumplimiento de estas reglas de posicionamiento puede hacer que el código genere excepciones inesperadas de tiempo de ejecución o datos corruptos.

Estoy de acuerdo en que no está claro, pero se reduce a "es tu trabajo Read()la etiqueta del elemento final del contenedor".

Escribí un artículo sobre el tema con ejemplos, ya que la documentación de MSDN no está clara y los ejemplos que puede encontrar en la web se implementan incorrectamente la mayoría de las veces.

Las trampas son el manejo de locales y elementos vacíos junto a lo que Marc Gravell ya mencionó.

http://www.codeproject.com/KB/XML/ImplementIXmlSerializable.aspx

Sí, todo es un campo minado, ¿no? La respuesta de Marc Gravell lo cubre más o menos, pero me gustaría agregar que en un proyecto en el que trabajé nos pareció bastante incómodo tener que escribir manualmente el elemento XML externo. También resultó en nombres de elementos XML inconsistentes para objetos del mismo tipo.

Nuestra solución fue definir nuestra propia IXmlSerializableinterfaz, derivada de la del sistema, que agregó un método llamado WriteOuterXml(). Como puede adivinar, este método simplemente escribiría el elemento externo, luego llamaría WriteXml()y luego escribiría el final del elemento. Por supuesto, el serializador XML del sistema no llamaría a este método, por lo que solo fue útil cuando hicimos nuestra propia serialización, por lo que puede o no ser útil en su caso. Del mismo modo, agregamos un ReadContentXml()método, que no leía el elemento externo, solo su contenido.

Si ya tiene una representación XmlDocument de su clase o prefiere la forma XmlDocument de trabajar con estructuras XML, una forma rápida y sucia de implementar IXmlSerializable es simplemente pasar este xmldoc a las diversas funciones.

ADVERTENCIA: XmlDocument (y / o XDocument) es un orden de magnitud más lento que xmlreader / writer, por lo que si el rendimiento es un requisito absoluto, ¡esta solución no es para usted!

class ExampleBaseClass : IXmlSerializable { 
    public XmlDocument xmlDocument { get; set; }
    public XmlSchema GetSchema()
    {
        return null;
    }
    public void ReadXml(XmlReader reader)
    {
        xmlDocument.Load(reader);
    }

    public void WriteXml(XmlWriter writer)
    {
        xmlDocument.WriteTo(writer);
    }
}

La implementación de la interfaz está cubierta por las otras respuestas, pero quería agregar mis 2 centavos para el elemento raíz.

En el pasado aprendí a preferir colocar el elemento raíz como metadatos. Esto tiene algunos beneficios:

• Si hay un objeto nulo, aún puede serializar
• Desde el punto de vista de la legibilidad del código, tiene sentido

A continuación se muestra un ejemplo de un diccionario serializable donde el elemento raíz del diccionario se define de esa manera:

using System.Collections.Generic;

[System.Xml.Serialization.XmlRoot("dictionary")]
public partial class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, System.Xml.Serialization.IXmlSerializable
{
            public virtual System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public virtual void ReadXml(System.Xml.XmlReader reader)
    {
        var keySerializer = new System.Xml.Serialization.XmlSerializer(typeof(TKey));
        var valueSerializer = new System.Xml.Serialization.XmlSerializer(typeof(TValue));
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
        if (wasEmpty)
            return;
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");
            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
            Add(key, value);
            reader.ReadEndElement();
            reader.MoveToContent();
        }

        reader.ReadEndElement();
    }

    public virtual void WriteXml(System.Xml.XmlWriter writer)
    {
        var keySerializer = new System.Xml.Serialization.XmlSerializer(typeof(TKey));
        var valueSerializer = new System.Xml.Serialization.XmlSerializer(typeof(TValue));
        foreach (TKey key in Keys)
        {
            writer.WriteStartElement("item");
            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
            writer.WriteStartElement("value");
            var value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
    }

    public SerializableDictionary() : base()
    {
    }

    public SerializableDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary)
    {
    }

    public SerializableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : base(dictionary, comparer)
    {
    }

    public SerializableDictionary(IEqualityComparer<TKey> comparer) : base(comparer)
    {
    }

    public SerializableDictionary(int capacity) : base(capacity)
    {
    }

    public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer) : base(capacity, comparer)
    {
    }

}