Bases de datos portables (II): Combinando Entity Framework con SQLite

English version here.

En el artículo anterior vimos que es posible hacer uso de ADO.NET para crear una aplicación que utilice SQLite como base de datos. De este modo, con una base de datos local y ampliamente utilizada es posible aumentar radicalmente la portabilidad de nuestra aplicación si ésta no requiere la potencia de una base de datos «tradicional». Sin embargo, la utilización de ADO.NET de forma directa implica dejar de lado todos los avances que Microsoft ha implementado a lo largo de estos últimos años en materia de mapeo objeto-relacional.

Ya que hemos aprendido a utilizar Entity Framework, ¿por qué no hacer uso de él con SQLite y dejarnos de «picar» código SQL de forma manual? A continuación veremos cómo podemos lograrlo.

Instalando el proveedor via NuGet

Lo primero que deberemos hacer será instalar en la aplicación el proveedor de datos para SQLite a través del gestor de paquetes NuGet. Para hacer esto, nos iremos a Herramientas > Gestor de paquetes y seleccionaremos la opción de gestionar paquetes NuGet para la solución.

En la sección Online, escribiremos SQLite en la caja de texto situada en la parte superior derecha y pulsaremos ENTER. Esperaremos a que se realice la búsqueda y seleccionaremos el primer paquete: System.Data.SQLite (x86/x64).

Una vez que el paquete haya sido descargado, seleccionaremos el proyecto en el cual queremos instalar el proveedor.

Creando el modelo de datos

Lo siguiente que deberemos hacer será crear el modelo de datos, el Entity Model, tal y como hemos visto en otras ocasiones. Haremos click derecho sobre nuestro proyecto, seleccionaremos Añadir elemento y, en la sección Data, marcaremos el modelo que buscamos, asignándole un nombre en la caja de texto destinada a ello.

Dado que partimos del artículo anterior, en el que la base de datos ya existía, marcaremos la opción «Generar desde base de datos». Por supuesto, también es posible generar el modelo de forma manual, pero en este caso dejaremos que sea Visual Studio quien lo cree por nosotros.

Crearemos una nueva conexión a base de datos pulsando sobre «Nueva conexión».

Como fuente de datos, seleccionaremos System.Data.SQLite Database File.

Buscamos el fichero que contiene la base de datos y pulsaremos sobre OK.

Finalmente, seleccionamos las tablas a mapear. En nuestro caso únicamente tenemos una tabla, así que la marcaremos para que sea mapeada.

El resultado será el siguiente:

No debemos olvidarnos de modificar el valor de StoreGeneratedPattern para que sea la base de datos quien gestione los identificadores de los registros (recordemos que era autoincrementable). Para hacer esto, cambiaremos este valor de None a Identity (identidad).

Un poco de código

No me extenderé mucho en la explicación del código, ya que se trata de LINQ to Entities, que ya hemos visto en anteriores artículos. No obstante, mostraré las operaciones equivalentes a ADO.NET del artículo anterior. Comenzaremos por la consulta:

        private void searchEF()
        {
            // Eliminamos el handler del evento RowEnter para evitar que se dispare al
            // realizar la búsqueda
            dataGrid.RowEnter -= dataGrid_RowEnter;

            // Instanciamos el contexto y cargamos un listado de usuarios
            var context = new clientsEntities();
            var users = from user in context.User
                        select user;

            // Cargamos el grid con los datos
            dataGrid.DataSource = users.ToList();

            // Restauramos el handler del evento
            dataGrid.RowEnter += dataGrid_RowEnter;
        }

Inserción y actualización:

        private void saveEF()
        {
            var context = new clientsEntities();

             // Si la caja de texto está vacía, se tratará de una inserción
            if (String.IsNullOrEmpty(txtId.Text))
            {
                // Creamos un nuevo usuario y lo añadimos, guardando a continuación los cambios
                User peter = new User { Name = txtName.Text, Surname = txtSurname.Text };
                context.User.Add(peter);
                context.SaveChanges();
            }

            // En caso contrario, se tratará de una modificación
            else
            {
                // Recuperamos el usuario cuyo identificador coincida con el de la caja de texto
                User u = context.User.Where(user => user.UserId == int.Parse(txtId.Text)).First();

                // Modificamos el contenido
                u.Name = txtName.Text;
                u.Surname = txtSurname.Text;

                // Guardamos los cambios
                context.SaveChanges();
            }
        }

Eliminación:

        private void deleteEF()
        {
            var context = new clientsEntities();

            if (!String.IsNullOrEmpty(txtId.Text))
            {
                // Recuperamos el usuario cuyo identificador coincida con el de la caja de texto
                int id = int.Parse(txtId.Text);
                User u = context.User.Where(user => user.UserId == id).First();

                // Lo eliminamos y salvamos los cambios
                context.User.Remove(u);
                context.SaveChanges();
            }
        }

El resultado será, como podemos imaginar, similar al visto en el artículo anterior:

Puedes descargarte el ejemplo completo (incluyendo los métodos de ADO.NET vistos en el artículo anterior) desde este enlace.