Posteado por: fzapataramirez | Jueves, julio 2, 2009

Serialización de datos en C#

Quizás muchos desarrolladores hayan escuchado hablar del termino “serializar la información” y no saber de que se trata. Pues bien, resulta que la serialización de datos no es otra cosa que transformar los datos de tal manera que pueda ser transferida por un canal (Internet, archivo plano, memoria, etc) a otro sistema. En otras palabras, si queremos compartir información de nuestro sistemas con otras aplicaciones o viceversa, tendremos que utilizar serialización de datos.

De manera nativa, el Framework de .NET nos ofrece la posibilidad de serializar la información en tres formatos: Binario, Soap, Xml.

La serialización en formato binario consiste en convertir la información a bytes y se utiliza comúnmente para los escenarios donde la información es transferida por la red hacia un sistema destino, el cual recibe dicha información y realiza el proceso inverso de la serialización = Deserializacion para construir el objeto (información) que fue transferido.
La serialización en formato Soap consiste en convertir los datos en un “documento estándar” en el cual se incluirá además de los datos a serializar, una serie de información adicional que será utilizada por el sistemas destino para construir el objeto original. Esta serialización es la que se utiliza en escenarios con Web Services.
Finalmente la serialización en formato Xml, consiste en transformar la información en un documento Xml que será interpretado por el sistema destino.

Los formatos de serialización Binario y Soap están contenidos en el namespace System.Runtime.Serialization, mientras que el Xml esta en el namespace System.Xml.Serialization.

Para ejemplificar cada escenario, supóngase que en nuestra aplicación se utiliza una entidad llamada Empleado definida como se muestra a continuación:

public class Empleado
{
    private int identificacion;
    private string nombre;
    private string apellido;
    private int edad;
    private string telefono;
    private DateTime fechaIngreso;
    private int diasLaborados;

    public int Identificacion
    {
        get
        {
            return identificacion;
        }
        set
        {
            identificacion = value;
        }
    }
    public string Nombre
    {
        get { return nombre; }
        set { nombre = value; }
    }

    public string Apellido
    {
        get { return apellido; }
        set { apellido = value; }
    }
    public int Edad
    {
        get { return edad; }
        set { edad = value; }
    }
    public DateTime FechaIngreso
    {
        get
        {
            return fechaIngreso;
        }
        set
        {
            fechaIngreso = value;
            DiasLaborados = (DateTime.Now.Subtract(fechaIngreso).Days);
        }
    }
    public string Telefono
    {
        get { return telefono; }
        set { telefono = value; }
    } 
    public int DiasLaborados
    {
        get
        {
            return diasLaborados;
        }
        set
        {
            diasLaborados = value;
        }
    }

}

Serialización en formato Binario
Como se mencionó anteriormente, éste método se utiliza generalmente para intercambiar información con otros sistemas a través de la red. Sin embargo para agilidad en la ilustración de su funcionamiento, los datos serializados en este post, se enviarán a un archivo de texto para visualizar su contenido. Esta serialización tiene la desventaja que solo funcionará entre aplicaciones .NET, es decir, que tanto la aplicación que serializa como la aplicación que deserializa deben ser aplicaciones desarrolladas bajo la plataforma .NET.

El primer paso para serializar un objeto en .NET, es incluir el atributo Serializable en la definición de nuestra clase así:

[Serializable]
public class Empleado
{…]

Esto le indicará al runtime de .NET que este objeto estará habilitado para ser serializado cuando se requiera, de lo contrario, se generará una excepción del tipo System.Runtime.Serialization.SerializationException.

Luego de esto, implementar la serialización binaria es tan sencillo como invocar el método Serialize de la clase BinaryFormatter que encontramos en el namespace System.Runtime.Serialization. Este método recibe como parámetros un Stream y el objeto que deseamos serializar, por ejemplo:

image

Si abrimos el archivo datoSerializado.txt, obtenemos:

image

Como se ve en la figura, la información obtenida después del proceso de serialización contiene una serie de caracteres especiales. Esto es porque en realidad estamos serializando en formato binario y el bloc de notas no esta en capacidad de interpretar este tipo de información. Sin embargo, en la vida real, se supone que ese stream es enviado a través de la red y recibido por una aplicación destino, la cual utilizará el método Deserialize del objeto BinaryReader para obtener el objeto Empleado que fue enviado inicialmente, así:

image

Lo cual da como resultado lo siguiente:

image

Profundizando un poco más en el como el runtime de .NET serializa los datos, debemos saber que en tiempo de ejecución el runtime convierte en bytes cada uno de los miembros del objeto sin importar el tipo o nivel de acceso (public, private, protected, etc). Esto en algunas ocasiones puede no ser lo que deseemos hacer, sino mas bien omitir algunos campos que consideramos no son necesarios al momento de serializar. En nuestro ejemplo especifico, para que queremos serializar el campo díasLaborados si puede ser calculado en tiempo de ejecución?. Esto implica un costo que podemos evitar ya que a mayor cantidad de miembros a serializar, mayor cantidad de información tendrá que ser transferida por red o almacenada en disco.

Para modificar el comportamiento de la serialización binaria, podemos utilizar el atributo NonSerialized en cada uno de los miembros que deseamos omitir, así:

[NonSerialized]
private int diasLaborados;

Con esto logramos que el resultado de la serialización sea el siguiente:

image

Donde se puede ver que ya no existe ninguna información referente al miembro diasLaborados. Sin embargo, al momento de ejecutar la aplicación destino y deserializar el objeto, obtenemos lo siguiente:

image 
Donde podemos observar que no se está calculando el valor del campo diasLaborados. Esto se debe a que el proceso de deserialización lo que hace es “recrear” el estado del objeto serializado y como el campo diasLaborados no está incluido en la información serializada, es omitido en el proceso de deserialización.

Por fortuna, existe la interfaz IDeserializationCallback, la cual incluye el método OnDeserialization que es llamado una vez termina el proceso de deserialización del objeto. Implementar esta interfaz solucionará nuestro problema ya que en dicho método podemos calcular el valor del miembro diasLaborados y así garantizamos que siempre que se realice una deserialización del objeto, se tendrá el estado completo del mismo. Para implementar la interfaz, se hace lo siguiente sobre el objeto Empleado:

[Serializable]
public class Empleado:IDeserializationCallback
{
     //Definicon de miembros

     #region IDeserializationCallback Members

        public void OnDeserialization(object sender)
        {
            DiasLaborados = (DateTime.Now.Subtract(fechaIngreso).Days);
        }

        #endregion

}

Así, ejecutando nuevamente el código que se encarga de realizar la deserialización tenemos:
 image

Serialización en formato SOAP.

La serialización en formato SOAP, consiste en utilizar un formateador especial que genera un documento SOAP con la información del objeto que deseamos serializar. Este formato de serialización es el utilizado en los servicios Web por su gran interoperabilidad entre sistemas ya que me permite tener los sistemas desarrollados bajo diferentes plataformas e incluso ejecutándose en diferentes plataformas (Linux, Windows, etc). Sin embargo, una de las desventajas que tiene este formato de serialización es que genera una gran cantidad de información al serializar nuestro objeto (debido a que se debe cumplir con el estándar de los documentos SOAP). Por este motivo, es necesario analizar que tipo de serialización utilizar en nuestra aplicación. Así entonces tenemos que la serialización binaria es la más eficiente pero sólo nos sirve para escenarios donde las aplicaciones están desarrolladas en .NET. Si por el contrario, necesitamos compartir nuestros datos con aplicaciones desarrolladas en otros lenguajes y además cumplir con el estándar SOAP, utilizaremos el formato SOAP y finalmente si lo que necesitamos es compartir información con aplicaciones desarrolladas en otros lenguajes pero no es necesario cumplir con ningún estándar, podemos utilizar el formato XML.

Para serializar en formato SOAP, sólo se debe utilizar el formateador SoapFormatter que se encuentra en el namespace System.Runtime.Serialization.Formatters.Soap, así:

image

Después de serializar obtenemos el siguiente resultado:

image 
Como se ve en la figura, el comportamiento de la serialización en formato SOAP también se ve afectada por el uso del atributo NonSerialized

Serialización en formato XML.

La serialización en formato XML consiste en transformar el objeto en un documento XML, donde por defecto, el nodo raíz será el tipo de dato que estemos serializando y sus miembros serán elementos de ese nodo raíz.
La implementación de la serialización XML difiere un poco de las presentadas anteriormente ya que no se utiliza un formateador sino que se hace utilizando la clase XmlSerializer que se encuentra en el namespace System.Xml.Serialization. Esta clase recibe como parámetro el tipo de dato que deseamos serializar. Por ejemplo:

image 
De esta manera le estamos indicando al objeto XmlSerializer que deseamos serializar un objeto de tipo Empleado, el cual al momento de invocar el método Serialize, genera un documento XML como el siguiente:

image

Como se puede ver en la figura anterior, el miembro diasLaborados fue serializado. Esto es porque la serialización XML no se ve afectada por el atributo NonSerialized. Sin embargo, la interface IDeserializationCallback si aplica para el proceso de la deserialización del objeto.

Para modificar el comportamiento de la serialización XML, se debe usar el atributo XmlIgnore sobre el miembro que deseamos omitir, así:

[XmlIgnore]
        public int DiasLaborados
        {
            get
            {
                return diasLaborados;
            }
            set
            {
                diasLaborados = value;
            }
        }

Es de notar que el atributo se ha utilizado sobre la propiedad DiasLaborados y no sobre el miembro diasLaborados. Esto es porque la serialización XML serializa únicamente los miembros públicos del objeto, por lo cual si usamos el atributo XmlIgnore sobre el miembro privado diasLaborados, el XmlSerializer igual seguiría generando el elemento DiasLaborados en el documento XML.

En el namespace System.Xml.Serialization, existen varios atributos que permiten modificar el comportamiento de la serialización XML y así obtener diferentes estructuras del documento XML generado. Uno de los atributos más usado es el XmlAttribute el cual se usa sobre cualquier miembro público y sirve para indicarle al runtime que dicho miembro lo genere como un atributo del nodo raíz y no como un elemento. Por ejemplo:

[XmlAttribute]
        public int Identificacion
        {
            get
            {
                return identificacion;
            }
            set
            {
                identificacion = value;
            }
        }
Luego de serializar nuevamente el objeto con el código ilustrado anteriormente, obtenemos:

image

Donde se ve claramente que el miembro Identificación es un atributo del nodo Empleado y no un elemento de dicho nodo como se había generado en el ejemplo previo.


Responses

  1. que bueno que sigas haciendo nuevas entradas!!!!

    no entiendo pero se que esto les sirve a muchos!!!!

    te amo

  2. Gracias muy bueno meacao el panorama

  3. thks!, me gusto mucho !

  4. Es justo lo que necesitaba.
    Muy buen artículo.

  5. Muchas Gracias por su aporte, excelentemente bien elaborado.

  6. Genial, gracias

  7. Gracias!!!

  8. Muchas gracias por tu aporte al conocimieto. Me sirvio de mucho esta infomaciòn. Continua son muy buenos tus articulos….🙂

  9. gracias muchas gracias

  10. Muy buen artículo. Enhorabuena.

  11. Muy buen aporte…Felicitaciones…

  12. Hola! Muy bueno, funciona…
    Mi pregunta ahora es, como serializo NO un objeto sino varios… Tengo una clase y dentro de ella tengo una lista de otra clase y quiero guardar elemento por elemento o toda la lista a vez….

    Encontré para serializar una List de Object, pero me sale un error que no puede convertir la lista de mi clase a la Lista de Object, asumo que es porque dentro tengo otra lista…


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

Categorías

A %d blogueros les gusta esto: