En el artículo anterior, mencioné que es a través de LINQ para SQL el mecanismo por el cual interactuamos completamente con la base de datos de nuestras aplicaciones de Silverlight para Windows Phone Mango. En este artículo veremos cómo programáticamente podemos crear una base de datos e interactuar completamente con ella.
Definición de la base de datos
Para definir el modelo de la base de datos para nuestras aplicaciones de Windows Phone Mango, debemos utilizar la técnica de “Primero el Código” (o “Code First” como se le conoce en el idioma inglés). Esta técnica te permite definir tu modelo por medio de clases y atributos. Una vez definidas las clases, éstas pueden ser utilizadas para generar el esquema de la base de datos o mapearse a una base de datos ya existente.
Creación de las tablas
Para definir una tabla para la base de datos debemos utilizar los atributos TableAttribute y ColumnAttribute, ambos del Espacio de Nombres System.Data.Linq.Mapping. Estos atributos, respectivamente, permiten identificar que una clase será una tabla dentro de la base de datos y que una propiedad dentro de esa clase será una columna dentro de la tabla.
Estos atributos mencionados están incluidos en el ensamblado System.Data.Linq.dll, por lo que deberás incluir una referencia a él en tu proyecto para utilizarlos.
El siguiente fragmento de código muestra la declaración de una tabla llamada Persona, la cual tendrá tres columnas: ID, Nombre y Empresa.
[Table]
public class Persona
{
[Column(IsDbGenerated = true, IsPrimaryKey = true)]
public int ID { get; set; }
[Column]
public string Nombre { get; set; }
[Column(CanBeNull = true)]
public string Empresa { get; set; }
}
Creación del contexto de datos
El contexto de datos es un objeto que representa a la base de datos. El contexto de datos contiene las tablas, que a su vez contienen las columnas que definen dicha tabla.
Para crear un contexto de datos, debemos crear una clase que herede de la clase base DataContext, disponible en el Espacio de Nombres System.Data.Linq. Será en esta clase en donde debemos declarar las tablas que tendrá la base de datos. Asimismo, la clase que definamos podrá invocar alguno de los constructores de la clase base DataContext para pasar como parámetro la cadena de conexión que indique a cuál base de datos estamos interesados en conectarnos.
El siguiente código muestra la declaración de la clase PersonaDataContext, la cual hereda de System.Data.Linq.DataContext y que establece que existirá una tabla llamada Personas.
public class PersonaDataContext : DataContext
{
public Table<Persona> Personas;
public PersonaDataContext(string connectionString) : base(connectionString) { }
}
Nota cómo el constructor de esta clase a su vez está invocando el constructor de su clase base. De esta manera permitiríamos utilizar una u otra cadena de conexión para reutilizar este contexto de datos en diferentes escenarios.
La cadena de conexión puede ser cualquiera de las siguientes opciones: una cadena con el prefijo isostore:/, el nombre del archivo de base de datos dentro del Almacenamiento Aislado o una cadena de conexión completa.
Creación de la base de datos
Para crear físicamente la base de datos en el Almacenamiento Aislado de la aplicación dentro del teléfono, debemos utilizar el método CreateDatabase() del contexto de datos. Para complementar esta tarea, también podemos ejecutar el método DatabaseExists() para determinar si la base de datos ya ha sido creada con anterioridad.
Para poder probar esta funcionalidad, he creado otra clase llamada PersonaDatabase, la cual encapsula la funcionalidad de creación física de la base de datos para la aplicación, tal y como lo muestra el siguiente código.
public class PersonaDatabase
{
public static PersonaDataContext GetDatabase()
{
var context = new PersonaDataContext("isostore:/personas.sdf");
if (!context.DatabaseExists())
{
context.CreateDatabase();
}
return context;
}
}
Inserción de datos
Una vez creada la base de datos, podemos insertar datos a sus respectivas tablas, todo esto por medio de los mismos mecanismos que LINQ para SQL ofrece. En el siguiente código se demuestra la creación de 1000 personas que serán finalmente insertadas en la tabla Personas dentro de la base de datos que creamos en pasos anteriores. Nota el uso del método SubmitChanges(); este método se asegura de finalizar la transacción hacia el motor de base de datos.
private static void CrearDatos()
{
var db = PersonaDatabase.GetDatabase();
for (int i = 0; i < 1000; i++)
{
db.Personas.InsertOnSubmit(new Persona()
{
Nombre = "Persona " + i.ToString(),
Empresa = "MVA"
});
}
db.SubmitChanges();
}
Consulta de datos
La consulta de datos hacia una base de datos de SQL Server CE usando LINQ para SQL es bastante sencilla si es que ya has utilizado el lenguaje LINQ en tus aplicaciones. El siguiente fragmento de código muestra el uso del lenguaje LINQ para consultar todas aquellas persona que incluyen en su nombre el número 5. El resultado de la consulta será la fuente de datos para un control ListBox.
private void ConsultarDatos()
{
var query = from persona in PersonaDatabase.GetDatabase().Personas
where persona.Nombre.Contains("5")
orderby persona.ID
select persona;
lista.ItemsSource = query.ToList();
}
La siguiente ilustración, muestra la aplicación ejecutando y después de haber consultado los datos según el código anterior.
Nota: Para este ejemplo, hice override del método ToString() en la clase Persona para poder mostrar contenido significativo dentro del ListBox, sin necesidad de hacer una Plantilla de Datos; lo cual es altamente recomendable en una aplicación en la vida real, pero no es el enfoque del tema que aquí estamos tratando.
Actualización de datos
Para actualizar los datos de una tabla de la base de datos local en una aplicación, debemos hacerlo igualmente bajo los mecanismos propios de LINQ para SQL, lo cual resulta bastante fácil.
Para demostrar este concepto, al proyecto de prueba he agregado una nueva página llamada Actualizacion.xaml, a la cual se navega después de seleccionar un elemento del ListBox que muestra la lista de personas. En esta nueva página se incluye un TextBox para cambiar el nombre de la persona seleccionada y finalmente, después de pulsar en el botón “Aceptar” los cambios son guardados de regreso en la base de datos con el siguiente código:
private void Guardar()
{
persona.Nombre = txtNombre.Text;
dataContext.SubmitChanges();
}
Es justamente el método SubmitChanges() el único mecanismo por el cual la base de datos es efectivamente actualizada con los cambios.
Nota: El proyecto de ejemplo aquí usado no necesariamente cumple con las mejores prácticas y/o recomendaciones arquitectónicas para una aplicación en producción, sino que únicamente trata de demostrar los conceptos de acceso a bases de datos locales aquí tratados.
Actualización del esquema de la base de datos
Los cambios pueden ocurrir en todo momento y el estar preparados para ello es sumamente importante para poder construir aplicativos robustos, extensibles y de fácil mantenimiento.
La clase DatabaseSchemaUpdater nos permite realizar modificaciones a un esquema pre existente de base de datos, como por ejemplo: modificaciones a las tablas, columnas, índices, claves foráneas y asociaciones, etc.
Método CreateDatabaseSchemaUpdater
El método CreateDatabaseSchemaUpdater del objeto de contexto de datos nos permite hacer las actualizaciones adecuadas al esquema de la base de datos. Por ejemplo, el siguiente código agrega una nueva tabla al esquema:
var context = new PersonaDataContext(“isostore:/personas.sdf");
var updater = context.CreateDatabaseSchemaUpdater();
updater.AddTable<Producto>();
O tal vez, quisieras agregar una nueva columna a una tabla ya existente:
updater.AddColumn<Persona>("FechaNacimiento");
Finalmente, debemos ejecutar el método Execute() para poder realizar los cambios en el esquema de la base de datos:
updater.Execute();
Resumen
Windows Phone Mango incluye SQL Server CE, un motor de base de datos relacional para poder almacenar cualquier tipo de cantidad de datos de manera privada en nuestras aplicaciones para el teléfono. El mecanismo por el cual podemos interactuar con esta base de datos en LINQ para SQL, ya que la ejecución directa de sentencias Transact-SQL no está permitida por motivos de rendimiento. LINQ para SQL nos permite definir la base de datos y también nos permite realizar las operaciones CRUD necesarias para nuestros aplicativos, lo cual demuestra una vez más lo importante que es comprender y adoptar este moderno lenguaje de consultas.
Estoy preparando los temas para los módulos avazados de las carreras de Silverlight y Windows Phone en Microsoft Virtual Academy (MVA). Por este motivo y para poder conocer el interés de los diversos temas que se pueden tocar, he creado las siguientes encuestas, las cuales tienen como objetivo el que me ayuden a conocer qué temas se deberían incluir y que otros, tal vez, no son tan necesarios.
![SNAGHTML20253b5[4]](http://rdiazconcha.com/wp-content/uploads/2011/10/SNAGHTML20253b54.png "SNAGHTML20253b5[4]")
![SNAGHTML1e461f7[4]](http://rdiazconcha.com/wp-content/uploads/2011/10/SNAGHTML1e461f74.png "SNAGHTML1e461f7[4]")
View-ViewModel (MVVM). ¡Los conceptos que aquí aprendas se pueden emplear en Aplicaciones de Escritorio construidas con Silverlight 4 o 5, y también en aplicaciones de Windows Phone 7 y 7.5!
)
![SNAGHTML700ad62[4]](http://rdiazconcha.com/wp-content/uploads/2011/08/SNAGHTML700ad624.png "SNAGHTML700ad62[4]")
