[How To] Simple serializador utilizando la clase XmlSerializer

En ocasiones es necesario que nuestras clases puedan verse como archivos XML estructurados, lo primero que se nos viene a la cabeza es que necesitamos armar todo un conjunto de reglas para poder ajustar los detalles según sean necesarios.

Vamos a colocar un escenario común de complejidad media. Digamos que tenemos un servicio Web en Java el cual necesita un XML formateado según las especificaciones de éste. El archivo XML que el servicio Web Java necesita es como sigue:

?<?xml version="1.0" encoding="utf-8"?>
<ejemplo Atributo1="" otroatributo="soy otro atributo">
    <Codigo>0</Codigo>
    <Texto />
    <Fecha>2017-02-14T21:25:39.4120419-03:00</Fecha>
</ejemplo>

Entonces lo que debemos hacer es utilizar la clase XmlSerializer, para poder convertir nuestra clase en un archivo XML según la necesidad o bien convertir de XML a un objeto que hayamos creado.

Serializar una clase

Aquí recibimos como parámetro un objeto y lo convertimos a XML.

Primeramente, creamos la clase (que se convertirá al formato XML):

using System;
using System.Xml.Serialization;

namespace ConsoleBlog
{
    [XmlRoot("ejemplo")]
    public class Ejemplo
    {
        private int codigo = 0;
        private string nombre = string.Empty;
        private DateTime fecha = DateTime.Now;
        private string atributo1 = string.Empty;
        private string atributo2 = "soy otro atributo";

        private string nomeincluyen = ":(";

        [XmlElement]
        public int Codigo
        {
            get
            {
                return codigo;
            }

            set
            {
                codigo = value;
            }
        }

        [XmlElement("Texto")]
        public string Nombre
        {
            get
            {
                return nombre;
            }

            set
            {
                nombre = value;
            }
        }

        [XmlElement]
        public DateTime Fecha
        {
            get
            {
                return fecha;
            }

            set
            {
                fecha = value;
            }
        }

        [XmlAttribute]
        public string Atributo1
        {
            get
            {
                return atributo1;
            }

            set
            {
                atributo1 = value;
            }
        }

        [XmlAttribute("otroatributo")]
        public string Atributo2
        {
            get
            {
                return atributo2;
            }

            set
            {
                atributo2 = value;
            }
        }

        [XmlIgnore]
        public string Nomeincluyen
        {
            get
            {
                return nomeincluyen;
            }

            set
            {
                nomeincluyen = value;
            }
        }
    }
}

El método para serializar la clase y convertirlo a XML sería:

public static string SerializarXML()
{
    //XML a ser retornado
    string resultado = string.Empty;

    //Variables para definición de XML
    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
    XmlSerializer serializer = new XmlSerializer(typeof(Ejemplo));
    Ejemplo ejemplo = new Ejemplo();
    Encoding encoding = Encoding.GetEncoding("UTF-8");          
    XmlWriterSettings xmlWriterSettings = new XmlWriterSettings
    {
        Indent = true,
        OmitXmlDeclaration = false,
        Encoding = encoding
    };

    //Agregar un espacio de nombres vacío
    ns.Add("", "");

    //Se utiliza using para que el objeto sea eliminado luego de su uso
    using (var stream = new MemoryStream())
    {
        //Creamos un XML
        using (var xmlWriter = XmlWriter.Create(stream, xmlWriterSettings))
        {
            //Convertimos la clase en XML
            serializer.Serialize(xmlWriter, ejemplo, ns);
        }
        //Asignamos el XML creado a nuestra variable
        resultado = encoding.GetString(stream.ToArray());
    }

    return resultado;
}

Luego realizamos la llamada y retornamos el XML:

static void Main(string[] args)
{
    string xml = Program.SerializarXML();

    Console.WriteLine(xml);

    Console.ReadKey();
}

Deserializar un XML

Aquí recibimos como parámetro una cadena de caracteres (string) y lo convertimos a un objeto .NET.
Primeramente, creamos el método (que convertirá el formato XML a un objeto):

public static Ejemplo DeserializarXML(string xml)
{
    //Objeto a ser retornado
    Ejemplo resultado = null;
    //Variables
    XmlSerializer serializer = new XmlSerializer(typeof(Ejemplo));
    //Lector de XML
    using (TextReader reader = new StringReader(xml))
    {
        try
        {
            //Convertimos XML a clase
            resultado = serializer.Deserialize(reader) as Ejemplo;
        }
        catch (Exception ex)
        {
            //Si hay error lo imprimimos
            Console.WriteLine(ex.Message);
        }
    }

    return resultado;
}

Luego realizamos la llamada y retornamos el objeto.