Persistiendo datos en disco con Visual Basic
Muchos programadores saben que cuando creamos una clase, ésta puede ser serializada o no (marshalling).
La serialización permite codificar un objeto para que éste sea enviado por un canal de comunicaciones, persistido, o almacenado en un medio físico (base de datos, fichero, envío por mail, etc).
La idea es que el objeto sea transmitido o consumido por el mismo o por otro proceso.
Para entender este planteamiento, pongamos un ejemplo teórico de esta filosofía de trabajo.
Tenemos un objeto con unas propiedades. Asignamos valores a las propiedades y persistimos los datos en memoria.
Una vez que tenemos los datos definitivos en memoria, persistimos físicamente los datos en un fichero en disco.
Otro proceso, se encargará de leer la información del fichero en disco y convertirla nuevamente a un objeto del mismo tipo que el original para crear una copia idéntica de los datos que se persistieron, de manera tal que podamos trabajar con los mismos datos que teníamos previamente en memoria.
El planteamiento teórico marcado quedaría resumido con el siguiente gráfico:
Si alargamos este proceso en el tiempo o si pensamos en sistemas geográficamente separados, entenderemos que la persistencia de información puede resultar muy útil.
Un ejemplo de utilidad de persistencia de información la podemos encontrar en los flujos de datos o workflows o en los envíos de datos y objetos por redes.
Ahora bien, ¿cómo llevar a cabo la persistencia de datos de forma práctica?.
Crearemos una aplicación dentro de la cual insertaremos tres (3) controles Label, tres (3) controles TextBox, y dos (2) controles Button.
La idea es que al iniciarse la aplicación, se cree un objeto determinado y lea sus datos por defecto presentándolos por pantalla.
El usuario podrá modificar los datos que considere oportuno y pulsar el control Button para persistir la información en disco.
Una vez hecho esto, la misma aplicación será capaz de abrir el fichero con el objeto persistido. Para ello, pulsaremos el segundo control Button que se encargará de realizar esta acción.
El código de la aplicación viene totalmente comentado y creo que es lo suficientemente clarificador por sí solo.
Por un lado, crearemos la clase de nombre Product:
»’ Clase Product encargada de almacenar la informacide un producto.
»’ Esta información puede ser serializada y persistida.
»’ </summary>
»’ <remarks></remarks>
<Serializable()> Public Class Product #Region «VARIABLES» »’ <summary>
»’ Variable que almacena el nombre del producto.
»’ </summary>
»’ <remarks></remarks>
Public Name As String = «» »’ <summary>
»’ Variable que almacena la cantidad pedida.
»’ </summary>
»’ <remarks></remarks>
Public Quantity As Double = 100.0
»’ <summary>
»’ Variable que indica el impuesto aplicable al producto.
»’ </summary>
»’ <remarks></remarks>
Public Tax As Double = 16.0 #End Region
#Region
«CONSTRUCTORS» »’ <summary>»’ Clase del constructor.
»’ </summary>
»’ <remarks></remarks>
Public Sub Product()
End Sub ‘ Product Constructor »’ <summary>
»’ Clase del constructor.
»’ </summary>
»’ <param name=»name»></param>
»’ <param name=»quantity»></param>
»’ <param name=»tax»></param>
»’ <remarks></remarks>
Public Sub Product(ByVal name As String, ByVal quantity As Double, ByVal tax As Double)
Me.Name = name
Me.Quantity = quantity
Me.Tax = tax
End Sub ‘ Product Constructor #End Region
End
Class ‘ Product Class
Por otro lado, crearemos nuestra aplicación Windows de prueba:
Imports
System.IOImports System.Runtime.Serialization.Formatters.Binary »’ <summary>
»’ Clase del formulario principal de la aplicacion.
»’ </summary>
»’ <remarks></remarks>
Public Class MainForm #Region «PROPERTIES» »’ <summary>
»’ Variable local utilizada para la propiedad File.
»’ </summary>
»’ <remarks></remarks>
Private m_FileName As String »’ <summary>
»’ Propiedad File para almacenar la ruta y fichero en
»’ el cual se persisitira la informacion.
»’ </summary>
»’ <value></value>
»’ <returns></returns>
»’ <remarks></remarks>
Private Property FileName() As String
Get
Return m_FileName
End Get
Set(ByVal value As String)
m_FileName = value
End Set
End Property
#End
Region#Region
«MainForm» »’ <summary>»’ MainForm_Load que se lanza al ejecutarse la aplicacion.
»’ </summary>
»’ <param name=»sender»></param>
»’ <param name=»e»></param>
»’ <remarks></remarks>
Private Sub MainForm_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
‘ Indicamos la ruta y nombre del fichero a persistir.
Me.FileName = «D:TEMPProductClass.dat»
‘ Declaramos la clase.
Dim clase As New Product()
‘ Llamamos al metodo que se encarga de mostrar los datos
‘ de la clase por pantalla.
ShowDataProduct(clase)
End Sub
#End
Region#Region
«METHODS» »’ <summary>»’ Mencargado de mostrar los datos en pantalla de un objeto Product.
»’ </summary>
»’ <param name=»product»>Clase Product con la informacion a mostrar.</param>
»’ <remarks></remarks>
Private Sub ShowDataProduct(ByVal product As Product)
‘ Mostramos el nombre del producto.
Me.txtName.Text = product.Name
‘ Mostramos la cantidad solicitada para ese producto.
Me.txtQuantity.Text = product.Quantity.ToString()
‘ Mostramos el impuesto asociado al producto.
Me.txtTax.Text = product.Tax.ToString()
End Sub
#End
Region#Region
«EVENTS» »’ <summary>»’ Evento lanzado al hacer clic sobre el boton de persistir la informacion.
»’ </summary>
»’ <param name=»sender»></param>
»’ <param name=»e»></param>
»’ <remarks></remarks>
Private Sub btnPersist_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnPersist.Click
‘ Declaramos un objeto Product.
Dim product As New Product()
‘ Indicamos el nombre del producto.
product.Name = Me.txtName.Text
‘ Indicamos la cantidad de productos solicitados.
product.Quantity = Convert.ToDouble(Me.txtQuantity.Text)
‘ Indicamos el impuesto a aplicar al producto.
product.Tax = Convert.ToDouble(Me.txtTax.Text)
‘ Declaramos un objeto de tipo Stream y creamos el fichero
‘ para escribir o serializar la informacion sobre el.
Using fileStream As FileStream = File.Create(Me.FileName)
‘ Declaramos un objeto de tipo BinaryFormatter.
Dim persist As New BinaryFormatter()
‘ Serializamos los datos y los persistimos
‘ sobre el fichero que hayamos indicado.
persist.Serialize(fileStream, product)
‘ Mostramos un mensaje en pantalla indicando
‘ que se ha realizado la accion.
MessageBox.Show(«Los datos han sido persistidos correctamente.»)
End Using
End Sub »’ <summary>
»’ Evento lanzado al hacer clic sobre el boton de obtener la informacion persistida.
»’ </summary>
»’ <param name=»sender»></param>
»’ <param name=»e»></param>
»’ <remarks></remarks>
Private Sub btnReadObject_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnReadObject.Click
‘ Si existe el fichero persistido, realizados la accion de
‘ recuperacion de sus datos y mostrarlos en pantalla.
If (File.Exists(Me.FileName)) Then
Try
‘ Declaramos un objeto Product.
Dim product As New Product()
‘ Declaramos un objeto de tipo Stream y leemos el fichero
‘ que contiene la informacion persistida.
Using fileStream As FileStream = File.OpenRead(Me.FileName)
‘ Declaramos un objeto de tipo BinaryFormatter.
Dim persist As New BinaryFormatter()
‘ Obtenemos los datos persistidos y los deserializamos.
product = CType(persist.Deserialize(fileStream), Product)
‘ Llamamos al metodo que se encarga de mostrar los datos
‘ de la clase por pantalla.
ShowDataProduct(product)
‘ Mostramos un mensaje en pantalla indicando
‘ que se han lelos datos persistidos.
MessageBox.Show(«Datos persistidos leidos correctamente.»)
End Using
Catch ex As Exception
‘ Mostramos un mensaje en pantalla indicando
‘ que se ha producido un error.
MessageBox.Show(«Se ha producido un error a la hora de leer la informacion persistida.» & _
Environment.NewLine & _
Environment.NewLine & _
«Mensaje original del error:» & _
Environment.NewLine & _
ex.Message.ToString())
End Try
Else
‘ Mostramos un mensaje en pantalla indicando
‘ que se no se han encontrado datos persistidos.
MessageBox.Show(«No se ha encontrado ninguna informacion persistida.»)
End If
End Sub
#End
RegionEnd
Class ‘ MainForm Class
En el código, se utilizan los namespaces System.IO (utilizado para escribir y leer el fichero con información persistida a través de la clase Stream) y System.Runtime.Serialization.Formatters.Binary (utilizado para serializar y deserializar la información del objeto a través de la clase BinaryFormatter).
Nuestra aplicación en ejecución tendrá el siguiente aspecto:
Si quieres acceder al código de la aplicación, lo podrás hacer en este enlace (25 Kb):
3 Responsesso far
Interesante !!! Luego se puede ir complicando con el versionado, si van cambiando las propiedades o métodos de las clases (de esos objetos.
Y serialización aplicada a WCF todavía más.
salu2
Se puede extender y complicar tanto como queramos.
Persistir los datos es almacenarlos de alguna manera (incluso en base de datos) para luego consumirlos en un tiempo «t» que deseemos diferente del momento en el que se generaron esos datos, e incluso en otro proceso o aplicación diferente.
Además, este mismo ejemplo con tres o cuatro líneas cambiadas en su mínima expresión, permite persistir colecciones de objetos.
En el ejemplo, un List(Of Product).
La transmisión por red, etc., queda libre para aplicarla de acuerdo a la problemática con la que nos encontremos en un momento dado. 🙂
me aburre le diverian deponer mas dibujitos