Developer's Diary

9 febrero, 2011

Curso de C# – Control de Ficheros II

Buenas de nuevo.

Continuamos con nuestro curso para aprender nociones básicas de C#, en esta ocasión volvemos a hablar de ficheros, pero vamos a centrarnos en la serialización de los mismos.

La serialización de ficheros podría considerarse la conversión de datos lógicos de nuestra aplicación, en información almacenada en ficheros que posteriormente podrá ser retomada en nuestra aplicación. De esta manera, podemos almacenar datos, de una manera más automatizada y que nos resulte más fácil para nosotros. A diferencia de como ocurría en nuestro curso anterior. Existen varias formas de serializar nuestra información dentro de un fichero. Estas son:

  • Binario
  • SOAP
  • XML

En este artículo, nos vamos a centrar en la serialización binaria y principalmente la de XML, que es la más conocida.

El principal interes de tomar la habilidad por la serialización, es que, los ficheros que generemos serán completamente entendibles por nuestra aplicación, además de que se encontraran completamente codificados. Si en el anterior apartado, nosotros eramos los encargados de crean una posible “serialización” en este caso, es el Framework el que se encargará por nosotros de realizar tal tarea

Pasemos ya a comenzar a explicar como funciona la serialización Binaria.

Serialización Binaria
Al igual que la anterior ocasión, todas las clases que vamos a necesitar para realizar nuestra serialización se encuentran dentro del espacio de nombres System.IO, en esta ocasión también vamos a requerir de el espacio de nombres System.Runtime.Serialization.Formatters.Binary. Por lo tanto debemos añadir dentro de nuestro proyecto de prueba, tales espacio de nombres, para poder usarlo con mayor comodidad.

Para nuestra serialización vamos a reutilizar nuestra clase Pelota, que ya pudimos usar anteriormente, en la sección del curso en la que vimos creación de clases, recordemos un poco su estructura.

public Class Pelota

{

public Pelota(int tamaño , string color , string nombre , int peso)

{

m_tamaño = tamaño;

m_color = color;

m_nombre = nombre;

m_peso = peso;

}

private int m_tamaño = O;

private string m_color = String.Empty;

private string m_nombre = String.Empty;

private int m_peso = O;

public int Tamaño{get;set;}

public string Color{get;set;}

public string Nombre{get;set;}

public int Peso{get;set;}

public int Botar()

{

Console.WriteLine(“Bote”);

return 1;

}

}

Más o menos era una cosa similar a la que hemos puesto arriba, en esta ocasión solo trabajaremos con la clase base. Ahora vamos a instanciar una pelota dentro de nuestra aplicación y vamos a comenzar a serializarla binariamente.

Para la serialización binaria, volvemos a requerir de un objeto intermedio, al igual que cuando trabajabamos con ficheros binarios. En esta ocasión volvemos a usar la clase FileStream, para apoyarnos en nuestra creación del fichero.Por lo tanto, debemos crear un objeto FileStream que instanciaremos con la ubicación del fichero y con el modo de acceso, como vamos a generar un nuevo fichero, será de tipo FileMode.Create. La instanciación de nuestro serializador binario, no requiere de ningún parametro en su instanciación.No obstante cuando lo generamos, deberemos pasarle el stream que vamos a usar.

Por lo tanto el código de la serialización quedaría muy similar a este:

Pelota pelota = new Pelota(5 , “Amarilla” , “Tenis” , 10);
FileStream stream = new FileStream(fichero , FileMode.Create);

BinaryFormatter serializador = new BinaryFormatter();

serializador.Serialize(stream , pelota);

stream.Close();

Como podemos comprobar, el segundo parametro que necesita recibir nuestro serializador en el método serialize, es un objeto. Como absolutamente todas las clases que .Net heredan de una clase superpadre que en este caso se trata de Object, no debemos tener ningún problema, el serializador recibirá cualquier objeto como segundo parametro, ya sea una estructura, como una cadena, como una clase que hayamos creado nosotros mismos, en este caso nuestra clase Pelota.

Como hemos podido comprobar, en esta ocasión cuando terminamos de usar nuestro fichero, llamamos también al método Close, ya que hemos finalizado de realizar nuestro trabajo con el fichero.

Bueno, ya tenemos nuestro código completo, vamos a probarlo, vamos a lanzar la ejecución, parece que todo va correcto. Pero, de repente nuestra aplicación sufre una excepción. ¿Que es lo que ha ocurrido? La excepción nos indica que nuestro tipo Pelota no es serializable. ¿Por qué? Porque no le hemos añadido el atributo serializable. Mediante este atributo, indicamos que nuestra clase puede sufrir serialización que es lo que actualmente queremos hacer con la misma.

Para añadir este atributo a nuestra clase solo es necesario, poner el siguiente código [Serializable] encima de la declaración de nuestra clase, algo similar a esto:

[Serializable]

public class Pelota

De esta manera conseguiremos que la gestión de serialización pueda realizarse y que nos genere nuestro fichero, si este fichero lo abrieramos con un editor de texto, veríamos algo similar a lo siguiente:

Como podemos observar la mayoría de información dentro del fichero, ni siquiera es visible. Esto se debe a que toda la información ha quedado guardada de forma binaria.

Si en algún momento no quisieramos incluir algo dentro de nuestro fichero serializado deberemos situar un atributo que sea [NoSerializable] de esa manera, el formateador binario entendera que esa propiedad no debe ser incluida.

Para poder realizar la deserialización de nuestro fichero, solo tendremos que llamar al método Deserialize, este método recibe la ubicación del fichero y devuelve un objeto, dentro del fichero se indica que tipo de fichero es exactamente. No obstante debemos tener bastante cuidado al respecto. Hay que tener en cuenta que podemos provocar una excepción si intentamos deserializar un fichero en un tipo de objeto que no corresponde.

Serialización XML

Bien, ahora pasemos a nuestra segunda opción serialización en XML, si no sabeis lo que es un XML lo podéis ver perfectamente aquí. Como bien sabeis este tipo de lenguaje es muy similar al lenguaje de etiquetas de HTML, este tipo de estructuración de un fichero, permite un acceso más rápido a la información, que en un fichero convencional. Esto se debe a la estructura del mismo.

Volvemos a aprovechar la estructura que ya tenemos, de nuestra clase pelota. Pero vamos a cambiar la clase que se va a encargar de procesar la información. En esta ocasión usaremos XMLSerializer apoyada siempre de la clase FileStream.

Cuando instanciamos un objeto de la clase XMLSerializer, podemos comprobar que el constructor que acepta menos parámetros, nos pido un tipo de valor llamado tipo. En este Type, es ni nada más ni nada menos el tipo de objeto que vamos a serializar. Este método se incluye en todos los objetos que hay dentro de .Net ya que es un método que pertenece inicialmente al tipo Object. Ahora bien, para poder pasarle a esta clase el tipo que vamos a serializar, solo tenemos que tomar un objeto del tipo que hemos serializado y llamamos al método GetType sería algo similar a lo siguiente:

Pelota pelota = new Pelota();

XMLSerializer serializer = new XMLSerializer(pelota.GetType());

De esta manera obtenemos el tipo para poder pasarlo a nuestro serializador de tipo XML. Otro de los detalles importantes para que la serialización salga correctamente, es que el objeto en cuestión que queremos serializar tenga un constructor que no reciba parámetros, además de que todos los campos que queremos incluir en nuestro fichero se encuentren bien encapsulados, esto quiere decir que contengan las propiedades en cuestión, si cumplimos todos los requisitos anteriormente indicados tendremos una serialización correcta.

En el caso que no queramos que alguno de los parámetros de nuestra clase se conviertan en valores dentro del fichero XML solo tendremos que incluir el atributo XMLIgnore encima del mismo o simplemente no deberemos encapsular tal campo.

Para la ejecutar la serialización solo tendremos que llamar al método Serialize, como ocurría con el BinaryFormatter, para recuperar nuestros datos, solo tendremos que ejecutar el método Deserialize, no debemos olvidar, a la hora de deserializar que el objeto que estamos pasando es correcto.

Si hemos realizado correctamente todos los pasos, podremos abrir nuestro fichero generado por xml, mediante un bloc de notas o también desde un navegador y nos quedara algo similar a esto:

Hasta aquí nuestra segunda entrada relacionada con ficheros. En esta ocasión hemos podido aprender como realizar una serialización de ficheros, que nos puede resultar interesante, para pequeñas aplicaciones las cuales tal vez una base de datos pueda ser excesivo y de esta manera podamos tener una información guardada o para salvar datos que posteriormente serán cargados de una manera más eficiente.

Espero que os haya gustado, en la proxima entrada hablaremos de como usar ciertas clases dentro de System.IO que nos permiten manejar ficheros y carpetas dentro de nuestra aplicación.

Un saludo.


Anuncios

Dejar un comentario »

Aún no hay comentarios.

RSS feed for comments on this post. TrackBack URI

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

A %d blogueros les gusta esto: