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.

Windows Phone Mango incluye SQL Server CE, motor de bases de datos relacionales lo suficientemente pequeña para que ejecute en el teléfono, pero a la vez bastante poderosa como para cubrir todas las necesidades de almacenamiento de datos relacionales para nuestras aplicaciones.  En este artículo hablaremos de cómo crear una nueva base de datos para nuestras aplicaciones de Silverlight para Windows Phone Mango, así como las operaciones CRUD (Create, Read, Update, Delete) básicas.

La necesidad de una base de datos local

Hay una gran cantidad de escenarios en donde contar con una base de datos relacional es justamente uno de los requerimientos básicos.  Por ejemplo: el tener catálogos de datos locales que puedan ser utilizados cuando la señal de datos del teléfono se pierda, o un caché local de datos que posteriormente puedan ser sincronizados a un almacenamiento más robusto y persistente (la Nube, por ejemplo) y un largo etcétera.

SQL Server CE en Windows Phone Mango, cubre precisamente ese requerimiento.  Con esto obtenemos una gran cantidad de ventajas, como por ejemplo: tener a nuestro alcance un almacenamiento de datos robusto, el poder crear consultas complejas a dichos datos, no tener que referenciar ensamblados de terceros.  Adicionalmente a esto, todas las operaciones de tipo CRUD son manejadas eficientemente por el mismo motor, además de que contamos con un API consistente. 

Es muy importante mencionar que cada base de datos es privada para cada aplicación, y físicamente es guardada en el Almacenamiento Aislado privado que tiene cada aplicación en Silverlight para Windows Phone Mango, por lo que no es posible (al momento de estar escribiendo este artículo”) tener una base de datos común para varias aplicaciones dentro del teléfono.  También es de suma importancia destacar que SQL Server CE no corre como un servicio en segundo plano dentro del teléfono, sino que correrá únicamente en el mismo proceso que la aplicación que lo invoca.

Mencioné que hay algunas ventajas.  Claro que las hay.  Sin embargo, también hay algunas desventajas:

No se permite Transact-SQL directo

Es común entre los desarrolladores de aplicaciones que tengan que escribir ellos mismos las sentencias CRUD para realizar las operaciones en su base de datos.  En SQL Server CE para Windows Phone Mango no es posible ejecutar consultar Transact-SQL de manera directa.

Lo sé.  Para algunas personas, el no tener que escribir sentencias Transact-SQL de manera manual es más bien, una ventaja

No hay un diseñador visual

Si deseas crear un esquema para tu base de datos de SQL Server CE en Windows Phone Mango, lo debes hacer exclusivamente vía código.  Cabe mencionar que hay algunos “hacks” que han hecho algunos desarrolladores para convertir un archivo de base de datos a una versión de SQL Server CE de Mango, pero este artículo se basa en los fundamentos del motor y sus posibilidades oficiales.

Pero entonces, si no podemos ejecutar directamente Transact-SQL y tampoco contamos con un diseñador visual para poder crear nuestras bases de datos, sus tablas, sus columnas, etc. ¿cómo lo podemos hacer?

La respuesta a esa pregunta es LINQ para SQL.

LINQ para SQL

LINQ (ojo: se pronuncia LINK, no LINKIÚ como muchas personas escucho que lo hacen) para SQL es un OR/M (Object-Relational Mapper por sus siglas en inglés).  Un OR/M tiene como objetivo en la vida ser un framework que, basándose en un modelo relacional, deriva un modelo de clases y todas las operaciones CRUD pertinentes para ese modelo relacional… y nuestras aplicaciones pueden usar ese modelo de clases directamente sin necesidad de ejecutar explícitamente ni una sola línea del lenguaje SQL que soporte ese motor de base de datos en cuestión.  Eso es precisamente el por qué no es necesario ejecutar directamente cláusulas T-SQL hacia nuestras bases de datos de Windows Phone Mango.

LINQ para SQL es usado en Windows Phone Mango para todas las operaciones CRUD –como mencioné anteriormente-, y también para todas las operaciones de tipo DDL (Data Definition Language), es decir, para la creación del esquema de la base de datos, sus tablas, columnas, claves foráneas, etcétera.

LINQ para SQL está implementado solo de manera parcial en Windows Phone Mango.  Para mayor información consulta esta página.

Luego entonces, nuestras aplicaciones deben hacer uso del lenguaje LINQ, para poder realizar las operaciones hacia la base de datos.  El rol que juega LINQ para SQL es el traducir esas consultas de LINQ hacia Transact-SQL y ejecutarlas en el motor de base de datos.  Cuando la base de datos regrese resultados (por ejemplo, de una consulta) esos datos son traducidos de regreso a objetos que puedas utilizar dentro de tu aplicación.  Esta traducción –de ida y de vuelta- la realiza automáticamente LINQ para SQL sin tu intervención, por lo que la eficiencia al momento de programar se incrementa considerablemente.  Solo es cuestión de acostumbrarse a este paradigma y conocer sus diversas posibilidades.

En la siguiente parte de este artículo veremos cómo programáticamente crear una base de datos nueva dentro de una aplicación de Silverlight para Windows Phone Mango, llenarla de datos, consultar esos datos y actualizarlos.

Una de las características nuevas en la plataforma de desarrollo de Silverlight para Windows Phone 7.1 "Mango” es el ofrecer un mecanismo para crear programáticamente mosaicos “vivos”, y que estos sean fácilmente actualizables según ciertas condiciones ya sea mientras la aplicación esté ejecutando o no.

En este artículo veremos a detalle la creación de mosaicos dinámicos o “Live Tiles” (Mosaicos vivos, por su nombre en el idioma inglés), sus características y capacidades.

Mosaicos

Los mosaicos son –dentro del lenguaje de diseño Metro- la manera en la que las aplicaciones pueden ser ejecutadas, pero también el mecanismo por el cual las aplicaciones nos pueden avisar que ha sucedido algo de nuestro interés como usuarios finales.  Windows Phone 7.1 incluye dos tipos diferentes de mosaicos: Mosaicos Principales y Mosaicos Secundarios. 

Mosaicos principales

Por ejemplo, cuando tienes configurada una cuenta de correo electrónico en Windows Phone 7, el mosaico que representa la aplicación de correo electrónico se actualiza dinámicamente cuando llega a nuestro buzón un nuevo mensaje, este es un ejemplo de mosaico principal ya que no tuvimos que hacer nada extra para crearlo, sino que ya lo agrega la aplicación al momento de ser instalada.  Este tipo de mosaicos pueden ser creados automáticamente por la aplicación o a través de código.  Es muy importante mencionar que estos mosaicos no pueden ser anclados al menú de inicio automáticamente, sino que el usuario lo debe hacer manualmente.

Mosaicos secundarios

Silverlight para Windows Phone 7.1, soporta la creación programática de mosaicos secundarios para las aplicaciones.  Esto es de particular interés cuando nuestra aplicación requiere brindar al usuario diversas maneras de ejecutar la aplicación.  Por ejemplo, cada mosaico secundario podría representar un estado completamente diferente a otro en la aplicación, adicionalmente al mosaico principal que nos sirve para ejecutar el aplicativo en cuestión.

En la ilustración se muestra una aplicación que tiene un mosaico principal con el título “Mi App!”, mientras que el resto de mosaicos son secundarios.

Este tipo de mosaicos pueden ser creados únicamente a través de código, además de que se anclan automáticamente al menú de inicio tan pronto como son creados.

Características de los Mosaicos

Todos los mosaicos cuentan con las siguientes características, las cuales pueden ser modificadas según sea necesario:

• Título frontal
• Imagen de fondo frontal
• Contador numérico (valor del 1 al 99. Si no se establece, no aparecerá)
• Título para el reverso del mosaico
• Contenido para el reverso del mosaico
• Imagen del reverso del mosaico

Hablando específicamente de las imágenes de los mosaicos, estas deb ser de tipo PNG o JPG y deben tener un tamaño de 173 x 173 pixeles.  Si la imagen no tiene este tamaño, se escalará automáticamente.  Adicionalmente a esto, los archivos deben estar marcados como “Contenido”, dentro del panel de Propiedades en Visual Studio .NET.

Clase ShellTile

La clase ShellTile representa un mosaico de nuestra aplicación –ya sea el principal o alguno de los secundarios.  Esta clase está disponible en el Espacio de Nombres Microsoft.Phone.Shell, por lo que es buena idea incluir una cláusula using (o Imports en Visual Basic) en la parte inicial de nuestro código.

La clase ShellTile incluye dos miembros estáticos importantes: la propiedad ActiveTiles, la cual es un diccionario que representa todos los mosaicos de la aplicación en cuestión, siendo el primero en el diccionario el mosaico principal, y también el método Create(), el cual nos sirve para poder crear mosaicos secundarios.

El siguiente fragmento de código obtiene el mosaico principal de la aplicación.

//Obtiene el mosaico de la aplicación

var main = Microsoft.Phone.Shell.ShellTile.ActiveTiles.First();

Clase StandardTileData

Hay una especialización de la clase ShellTile: la clase StandardTileData.  Esta clase representa un mosaico que puede estar anclado al menú de inicio, por lo que puede tener las propiedades que indicamos anteriormente como título fronta y de reverso, imágenes, etc.

El siguiente fragmento de código configura el mosaico principal de la aplicación, tanto para la parte frontal como para la parte trasera.

var appTitle = ShellTile.ActiveTiles.First();

if (appTitle != null)
{
    var tileData = new StandardTileData();

    tileData.Title = "Mi Aplicación";
    tileData.Count = 7;
    tileData.BackgroundImage = new Uri("Imagenes/sl4logo.png", UriKind.Relative);
    tileData.BackContent = "Atrás";
    tileData.BackTitle = "Ejemplo";
    tileData.BackBackgroundImage = new Uri("Imagenes/WPLogo.png", UriKind.Relative);

    appTitle.Update(tileData);
}

Al ejecutar el anterior código y al anclar el mosaico al menú de inicio manualmente, veremos el resultado deseado, tal y como se muestra en la siguiente ilustración:

Es importante mencionar que cuando un mosaico tiene contenido en el reverso y éste está anclado al menú de inicio, automáticamente después de un lapso de tiempo el mosaico gira como si fuera un naipe para mostrar dicho contenido.

Creación de mosaicos secundarios

Para crear mosaicos secundarios, utilizamos el método Create() mencionado anteriormente.  Este método estático es parte de la clase ShellTile y solicita como parámetros la ruta dentro de la aplicación que este mosaico secundario representa, y también un objeto de tipo StandardTileData, con las propiedades visuales necesarias que requiera nuestro nuevo mosaico.

El Proyecto

Para probar esta funcionalidad, nuestra aplicación de prueba consta de dos páginas: MainPage.xaml y Nombre.xaml. En MainPage el usuario puede escribir su nombre y pulsar sobre el botón.  Al hacer esto, la aplicación navega hacia Nombre.xaml, pasando como parámetro el nombre escrito en la caja de texto de MainPage.  Aquí, el usuario puede pulsar en el botón “Crear mosaico secundario”, lo cual hará precisamente eso, identificando al nuevo mosaico con ese Uri único.

La siguiente ilustración muestra las dos páginas de la aplicación.

Es en el botón “Crear mosaico secundario” en donde está implementado el código para crear un mosaico secundario de la aplicación, tal y como se muestra a continuación.  Nota que lo primero que hace el código es asegurarse que no exista otro mosaico secundario con el mismo Uri.  Posteriormente a eso, se crea un nuevo objeto de tipo StandardTileData con el contenido visual adecuado.

if (ShellTile.ActiveTiles.Where((m) => m.NavigationUri 

   == NavigationService.Source).Count() == 0)
{
    StandardTileData newTile = new StandardTileData()
    {
        Title = nombre,
        Count = 1,
        BackgroundImage = new Uri("Imagenes/sl4logo.png", UriKind.Relative),
        BackTitle = "Mosaico Secundario",
        BackContent = "Creado: " + DateTime.Now.ToString(),
        BackBackgroundImage = new Uri("Imagenes/mva.png", UriKind.Relative)
    };

    ShellTile.Create(NavigationService.Source, newTile);
}

Una vez ejecutando la aplicación en el emulador, podemos probar esta funcionalidad creando tantos mosaicos secundarios como queramos.  Es importane mencionar que el mosaico principal de la aplicación no es necesario que esté en el menú de inicio para que los mosaicos secundarios estén anclados.  En la siguiente ilustración se muestran tres mosaicos secundarios creados con esta aplicación de prueba.

Resumen

Los mosaicos dinámicos o “Live Tiles” son una de las mejoras que podemos encontrar en Silverlight para Windows Phone Mango.  A través de esta característica podemos brindar a los usuarios de nuestras aplicaciones un mecanismo para poder llegar directamente al contenido que ellos desean, ya que cada mosaico puede representar una ruta diferente de acceso dentro de nuestras aplicaciones.