¿Cómo Acelerar el Emulador de Android?


Si eres un desarrollador Android, sabes que el emulador toma mucho tiempo para arrancar (sin mencionar el lento desempeño una vez que ya está funcionando) y esto afecta tu productividad.

Afortunadamente, si cuentas con un equipo razonablemente moderno con un procesador Intel® que tenga Intel® Virtualization Technology habilitada, puedes hacer uso de esta tecnología para acelerar significativamente el emulador de Android. En este artículo explicaremos los pasos necesarios para hacer esto. Es posible hacerlo tanto en sistema operativo Windows como en Mac OS y Linux. En los dos primeros casos se utiliza Intel Hardware Accelerated Execution Manager (Intel HAXM), y en el caso de Linux se utiliza KVM.

1. Introducción
A continuación te guiaremos para realizar la instalación del Intel® Hardware Accelerated Execution Manager (Intel HAXM), un motor de virtualización asistido por hardware (hipervisor) que usa Intel® Virtualization Technology (Intel VT) para acelerar el desarrollo de Android en Windows y OSX. También explicamos cómo configurar una máquina virtual basada en kernel (KVM) asistida por hardware en Linux.

2. Instalación 2.1. Prerrequisitos
  • Tener instalado el kit de desarrollo de software (SDK) de Android.
  • Tu equipo debe tener un procesador Intel compatible con Intel VT-x y EM64T, y con la funcionalidad Execute Disable (XD) Bit habilitada desde el BIOS.

2.2. Instalación en Windows

Después de haber instalado el SDK de Android, abre el SDK Manager. En la sección de extras, podrás encontrar el Intel HAXM.
Marca la casilla y haz clic en el botón “Install packages…”; cuando hayas instalado el paquete, el estado aparecerá como “Installed”. Esto es engañoso, ya que en realidad no queda instalado. El SDK tan sólo copia el ejecutable de Intel HAXM a nuestra máquina, pero todavía tenemos que instalarlo. Para instalar el ejecutable de Intel HAXM, busca en tu disco duro IntelHaxm.exe (o IntelHAXM.dmg en Mac OS X). Si dejaste todos los valores predeterminados, debería estar en C:Program FilesAndroidandroid-sdkextrasIntelHardware_Accelerated_Execution_ManagerIntelHaxm.exe.
Intel HAXM sólo funciona en combinación con una de las imágenes de sistema x86 de procesador Intel Atom. Al momento de publicar este artículo existen imágenes x86 disponibles para Android 2.3.3 (API 10), 4.0.3 (API 15), 4.1.2 (API 16), 4.2.2 (API 17) y 4.3 (API 18). Estas imágenes de sistema de Intel se pueden instalar de la misma manera que las imágenes basadas en ARM, mediante el administrador de SDK.
Cuando das clic en el ejecutable de IntelHaxm, se muestra una pantalla de bienvenida como esta:
Puedes ajustar la cantidad de memoria RAM que se asigna a Intel HAXM. Después de ajustarla, haz clic en “Next”. La pantalla siguiente confirma la asignación de memoria. Si todo está como lo desea, haz clic en “Install”.
A fin de poder instalar el Intel HAXM, debes tener habilitada Intel VT-x en el BIOS, si no, verás un error como este durante la instalación:
Si se produce este error, ve al BIOS y habilítala.
La segunda opción para descargar el Intel HAXM y la imagen de sistema del emulador x86 Emulator System Image es ir directamente al sitio web: http://software.intel.com/es-es/android y descargar de allí todos los componentes necesarios.

2.3. Instalación en Linux
Los pasos para acelerar el emulador de Android en Linux son diferentes que en Windows y Mac OS X, porque Intel HAXM no es compatible con Linux, así que es necesario usar KVM en su lugar. Los pasos que se muestran a continuación corresponden a Ubuntu* 12.04 y pueden diferir ligeramente en otras distribuciones de Linux.

2.3.1. Instalación de KVM
Para instalar y ejecutar KVM, primero necesitas comprobar que tu CPU admite virtualización de hardware. Tal vez la forma más práctica de hacer esto es con el comando “kvm-ok” que se encuentra en el paquete “cpu-checker”.
$ sudo apt-get install cpu-checker
$ sudo kvm-ok
Este comando nos indicará si nuestro equipo cuenta con la capacidad de ejecutar KVM y si ya está habilitado en el BIOS o tenemos que habilitarlo.
El siguiente paso es instalar la KVM y otros paquetes necesarios. Para hacerlo, escribe:
$ sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils
Si obtienes una pantalla de configuración de Postfix, selecciona “No configuration”.
A continuación, agrega tu usuario al grupo KVM y al grupo libvirtd. Para hacerlo, escribe:
$ sudo adduser your_user_name kvm
$ sudo adduser your_user_name libvirtd
Después de la instalación, vuelve a iniciar sesión y los cambios surtirán efecto. Para probar la instalación, escribe:
$ sudo virsh -c qemu:///system list
Ahora puedes ir al paso siguiente, que es crear y ejecutar el dispositivo virtual de Android (AVD). Este procedimiento es el mismo para Linux y Windows.

2.4. Cómo crear un AVD (dispositivo virtual de Android*)
Después de instalar el SDK e Intel HAXM (o KVM en Linux), puedes crear un dispositivo virtual que tenga emulación acelerada por hardware. Para hacerlo, ve a AVD Manager y crea un nuevo dispositivo. Asegúrate de seleccionar Intel Atom (x86) como CPU/ABI. Esta selección sólo aparece en el menú desplegable si tienes instalada la imagen de sistema x86 Intel; para que los gráficos sean más suaves, activa la emulación de GPU cuando crees el AVD.
Haz clic en New y crea tu AVD x86. Asegúrate de elegir una API compatible con imágenes de sistema x86, que CPU/ABI esté establecido en x86 y de haber habilitado la emulación de GPU (OpenGL ES*). Cuando hayas hecho esto, haz clic en Create AVD para crear el AVD.
Para iniciar el AVD x86, haz clic en Start y luego en Launch.
Si la instalación fue exitosa, cuando se esté iniciando el emulador, aparecerá un cuadro de diálogo que indicará que Intel HAXM se está ejecutando en modo virtual rápido. También puedes revisar los detalles en “About phone” dentro del emulador.
Conclusión
En este artículo hemos revisado cómo podemos apoyarnos en las capacidades de los procesadores Intel para acelerar el emulador para Android en Windows, Mac y Linux. La mejora de rendimiento que apreciarás con Intel HAXM o KVM depende de tu equipo, pero debería ser entre 5 y 10 veces mejor que al no usar aceleración.
Si deseas conocer más herramientas y recursos que ofrece Intel para desarrolladores Android, te recomendamos que visites la zona para desarrolladores Android en http://software.intel.com/es-es/android.


www.asociacionaepi.es



Google anuncia Dart, la aternativa a JavaScript

El gigante de Internet ha anunciado la versión 1.0 de Dart, un nuevo lenguaje web que amenaza con ser una alternativa viable y de código libre a JavaScript, para sitios y aplicaciones web.

Pero en realidad el debut de este lenguaje se produjo hace un par de años atrás, aunque su implementación no era todavía posible en programación. No fue hasta ahora, que Dart puede ser usado como un lenguaje que es mucho más fácil de aprender que JavaScript, además de que puede correr programas propios y, por supuesto, ser adaptado a otros navegadores que no sean Chrome.

La ventaja de uso de Dart por parte de los programadores es que es más veloz que las librerías en JavaScript, de un 42 a un 130% más rápido según benchmarks de Google. Sin embargo, Google se enfrentará al problema de que JavaScript es demasiado popular entre los programadores que han creado millones de sitios web con él. Migrar ahora hacia un lenguaje impuesto por Google parece ser una alternativa difícil.
De cualquier manera, Google se prepara para dar impulso a Dart con una serie de presentaciones dedicadas a programadores. En estos momentos, Blossom, Montage, Soundtrap, Mandrill y la propia Google, además de Adobe, drone.io y JetBrains ya están usando el nuevo lenguaje. Además, Google anuncia que ya hay 500 paquetes de librerías disponibles por parte de la comunidad.

www.asociacionaepi.es



Desarrollando en Android 4 – Parseando un XML

Vamos a tocar una parte muy importante de un proyecto: parsear un XML. Según lo definido inicialmente, la gracia de toda esta aplicación es que yo recibiré un archivo .xml y a partir de aquí mostraré en el mapa las posiciones. Para ello, vamos a parsear este archivo primero y luego vamos a utilizar los datos para insertar marcadores en nuestro mapa.
Parsear un XML
Antes de nada, qué significa “parsear”. El parseo es un proceso de análisis y posterior transformación de un bloque en un lenguaje/estructura determinada en otro bloqueo de lenguaje/estructura diferente. Básicamente lo que quiero es que mi programa sepa entender el archivo que le paso, y me detecte lo que son posiciones geográficas, lo que son títulos o el indicador de si está libre o no un parking.
Así que, antes de nada, he creado un archivo .xml que alamcena posiciones de parkings:
<?xml version=”1.0″ encoding=”UTF-8″?>
<ParkingPositions>
<parking>
<name>Parking UPC</name>
<lat>41.387179</lat>
<lng>2.1125849</lng>
<free>1</free>
</parking>
<parking>
<name>Parking Casa Adri</name>
<lat>41.3845864</lat>
<lng>2.1392143</lng>
<free>1</free>
</parking>
<parking>
<name>Parking Palau Reial</name>
<lat>41.38575629197152</lat>
<lng>2.1175289154052734</lng>
<free>0</free>
</parking>
<parking>
<name>Parking Liceo Frances</name>
<lat>41.392059</lat>
<lng>2.117139</lng>
<free>0</free>
</parking>
</ParkingPositions>
Este archivo no es nada más que un conjunto de objetos <parking> que contienen un nombre <name>, una latitud <lat>, una longitud <lng> y un indicador de si el parking está libre o no <free>. Ahora toca interpretarlo.
En Android se puede parsear un XML de muchas maneras: la que ellos proponen utilizando XMLPullParser, DOM o SAX entre muchos. Personalmente he probado de hacerlo de dos maneras diferentes, con el XMLPullParser y con SAX, y tras muchísimos muchísimos quebraderos de cabeza al final he optado por el SAX.
Nota: Muchísimas gracias a Salvador Gómez por su tutorial en el parseo con SAX, que ha sido de mucha utilidad.
Paso 1: La clase de objetos
El objetivo final del parseo es obtener una serie de objetos en el formato que queramos. Como yo quiero obtener parkings con los cuatro atributos mencionados anteriormente, lo primero que hay que hacer es crear la classe ParkingMarker:
Paso 2: El Handler
A medida que se parsea un documento se van produciendo eventos que se han de tratar. Estos eventos indican por ejemplo que se ha acabado una etiquetao que has llegado al final del documento entre otros.
Los principales eventos son:
  • startDocument(): comienza el documento XML.
  • endDocument(): termina el documento XML.
  • startElement(): comienza una etiqueta XML.
  • endElement(): termina una etiqueta XML.
  • characters(): fragmento de texto.
Así pues en nuestro código vamos a tratar todos ellos
Analicemos con detalle lo que hemos hecho. Primero hemos definido una lista de objetos parkings, un objeto parking y un objeto sbText. Este último sirve para ir almacenando el texto que se recupera del parseador.
En el startDocument, tan solo hay que instanciar los dos tipos de objeto y en startElement decimos que si nos encontramos con la etiqueta <parking> significa que empieza un nuevo objeto. La función characters tan solo va acumulando el texto para luego tratarlo.
Y la gracia de todo está en el endElement. Aquí definimos qué hay que hacer cuando llegas al final de un elemento. He definido en mi caso las siguientes situaciones:
  • Si estaba en la etiqueta <name>, almacena el contenido en el apartado name del ParkingMarker.
  • Si estaba en una de las etiquetas de <lat> o <lng> que lo almacene en su campo correspondiente
  • Si estaba en el campo <free>, que recoja el valor y si es un “1″ entonces asignaremos el valor de TRUE al campo y FALSE si es el caso contrario.
  • He añadido un caso en el que si no viene ni un “1″ o un “0″ que indique que ha habido error en el parseo.
Paso 3. El Parser
Y finalmente el parseador. Esta clase recibe una URL con el XML y empieza a Parsearlo utilizando el ParkingHandler que hemos creado anteriormente.
Insertando el Parseador al proyecto y añadiendo puntos al mapa
Aquí hay un tema delicado que he aprendido a base de prueba y error. Desde la versión 3 de Android, no se permite a las aplicaciones ejecutar operaciones de larga duración en el hilo principal que puedan bloquear temporalmente la interfaz de usuario. Así pues, hay que crear una llamada asíncrona que lo hará en segundo plano.
En resumen, lo que toca hacer ahora es lo siguiente. En el método onCreate añadimos las siguientes líneas:
RetrieveFeed task = new RetrieveFeed(); task.execute(“https://dl.dropboxusercontent.com/u/123539/parkingpositions.xml”);
Y al final de la MainActivity.java, justo antes de cerrarla creamos una clase que extienda AsyncTask
Analicemos también con más detalle lo que pasa aquí. En el primer método doInBackground definimos lo que se realiza en segundo plano. En nuestro caso es crear un nuevo parseador con la URL dada y ejectuarlo.
Y en onPostExecute ponemos lo que se ha de hacer a continuación: tratamos la lista y para cada elemento (parking) de ella
  • recuperamos la latitud y la longitud
  • si el parking está libre definimos el color verde y si está ocupado el color rojo
  • finalmente añadimos un marcador en la posición recuperada, con el nombre (también recuperado) por título y el icono de un color u otro según su estado.
Como véis, no es excesivamente complicado pero os puedo asegurar que me estuve horas y horas para conseguir que funcionase. Ahora ya lo tenéis todo bien puesto y funcionando a la perfección.
www.asociacionaepi.es



Colaboración entre Xamarin y Microsoft

Xamarin, la empresa de nuestro connacional Miguel de Icaza, está en tratos con Microsoft para llevar el desarrollo de iOS y Android a Visual Studio. La colaboración se anunció con la llegada oficial de Visual Studio 2013, en un evento que se celebró en Nueva York. La colaboración tiene tres puntos fundamentales:

  • Mejor integración de la tecnología de Xamarin con las herramientas y servicios de desarrollo de Microsoft. La recién lanzada Universidad Xamarin, ahora será gratis para los suscriptores de MSDN
  • Los subscriptores de MSDN tendrán un sistema de prueba exclusivo y opciones de precios para Xamarin, en equipo o de forma individual Xamarin anunció la disponibilidad de soporte para Visual Studio 2013 y para la biblioteca de clases portable .NET. Este es un entorno de .NET que permite crear bibliotecas que trabajen en un amplio rango de pl;ataformas .NET sin tener que recompilar. Esto permitirá a Xamarin usar la tecnología que tienen en iOS y Android para Visual Studio.

Xamarin empezó con el desarrollo de Mono, un sistema .NET para Linux y se ha enfocado recientemente en el desarrollo móvil cruzado, es decir, usar un sistema para compilar para otros sistemas. Usando la implementación .NET de Xamarin es posible escribir apps para iOS y Androisd en C# y por supuesto, se pueden escribir apps para Windows Phone 8 en C# también. Se puede incluso compilar para Mac OS X. Esto hace a .NET y C# la única plataforma cruzada con esta gama de productos. La mayoría de las características de C#, tipos anónimos, lambdas y LINQ, están disponibles.

Cabe decir que no se puede reusar el 100% del código porque el entorno gráfico para cada una de estas plataformas son muy diferentes. Sin embargo, se pueden acceder a los API nativos vía un conjunto estándar de bibliotecas. Xamarin dice que todo lo que se puede hacer en Objective C o Java, se puede hacer usando C#.

En iOS, por ejemplo, las apps se compilan al código nativo de ARM. Xamarin estima que el 75% del código puede ser compartido, pero por supuesto, esto dependerá de la aplicación. En Android, el compilador crea un lenguaje intemedio (IL), el cual es compilado usando el compilador JIT (Just In Time) para que corra de manera nativa.
Se puede usar Xamarin Studio o Visual Studio y se pretende que la integración de Visual Studio sea el núcleo de la colaboracion con Xamarin. Ser capaz de desarrollar para las tres plataformas más importantes de teléfonos usando el mismo IDE suena atractivo para los fanáticos de la plataforma .NET.

Xamarin indica que tiene ya una comunidad de unos 430 mil desarrolladores, con más de 20 mil cuentas registradas (que pagan). El costo de la suscripción es de 299 dólares para una licencia personal, pero sube a 1899 dólares para una licencia empresarial. Y esto es por plataforma, por desarrollador, por año. Con ello, debe quedar claro que Xamarin tiene un buen nivel de seguridad financiera. Se puede usar una versión gratuita para crear apps que pueden ser puestas en las tiendas virtuales.


www.asociacionaepi.es



Serialización de datos en C# en Binario, Soap y Xml

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, supongamos 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 diasLaborables;

    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; 
            diasLaborables= (DateTime.Now.Subtract(fechaIngreso).Days); 
        } 
    } 
    public string Telefono 
    { 
        get { return telefono; } 
        set { telefono = value; } 
    }  
    public int diasLaborables
    { 
        get 
        { 
            return diasLaborables
        } 
        set 
        { 
            diasLaborables = 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.

Después, 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 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 diasLaborables;

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 diasLaborables. 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.

www.asociacionaepi.es