miércoles, 30 de abril de 2014

[EntityFramework] Interactuando con nuestro contexto

Hola amigos, a lo largo de esta serie de Entity Framework hemos, visto cómo crear nuestro modelo a partir de nuestra base de datos usando el enfoque DataBaseFirst, y también cómo crearlos a través del enfoque CodeFirst, hemos visto las ventajas y forma de trabajo de cada uno, pero aún no hemos visto cómo interactuar con ese contexto generado, desde nuestras diferentes aplicaciones. Pues bueno eso lo vamos a ver en este artículo, en el cual observaremos cómo hacer consultas, inserciones, actualizaciones y eliminaciones en nuestra base de datos a través de nuestro contexto de Entity Framework.

Para iniciar hablemos un poco acerca del Api DbContext:

DbContext representa nuestro modelo conceptual, a través de él podemos acceder a nuestras entidades para consultarlas o realizar operaciones transaccionales sobre ellas, DbContext representa la combinación de dos patrones de diseño; unidad de trabajo y repositorio que permiten lograr leer los datos y agrupar los cambios que posteriormente serán escritos en la fuente de datos como una unidad. Para mayor información les comparto este link, y adicional estas fuentes sobre Unidad de trabajo y repositorio por si quieren profundizar en el tema. Adicional el ejemplo de implementación con C#.

Ahora sí, entremos en materia. Para nuestros ejemplos nos vamos a basar en un modelo muy sencillo el cual elaboramos en un ejemplo anterior Creando nuestra base de datos, basados en nuestro contexto es muy simple pero no es útil para efectos de nuestro ejemplo. Cómo vemos tenemos una entidad Producto y una Entidad categoría, las cuales podemos relacionar, aquí les dejo algunos ejemplos de cómo crear relaciones en CodeFirst Configurar una relación uno a uno en Code FirstConfigurando una relación de uno a muchos en Code First y Configurando una relación de muchos a muchos en Code First.

Realizando diferentes consultas a través de linq y lambda expresions:

Para realizar consultas en nuestra base de datos podemos usar linq o expresiones lambda, usando nuestro contexto y las entidades en las que deseemos realizar la consulta, para realizar consultas linq tenemos una sintaxis bien definida como si estuviéramos realizando una consulta a través de Transact Sql, por ejemplo una consulta básica consta de tres partes, from, where y select, la diferencia es que solo hasta el final especificamos que deseamos seleccionar, por ejemplo para seleccionar todos los productos cuyo código sea 1:

            using (var productosContext = new ProductosContext())
            {
                var productos = from c in productosContext.Productos
                    where c.Codigo == 1
                    select c;
            }

Podemos filtrar por cualquier campo, y seleccionar el que queramos, y de igual forma podemos hacer consultas en varias tablas a través de sus relaciones, y retornar tipos anónimos para soportar todos los campos como por ejemplo:

                var productos = from c in productosContext.Productos
                    from e in c.Categorias
                    select new
                    {
                        codigo = c.Codigo,
                        nombre = c.Nombre,
                        categoria = e.Nombre
                    };

Cabe aclarar que para estas consultas podemos usar múltiples operadores que nos ayuden a realizar nuestras consultas cómo por ejemplo funciones de agregado, filtro, agrupamiento, ordenamiento, combinación, entre otros. Cómo en este artículo no pretendemos profundizar mucho en las consultas linq, aquí les dejo algunos ejemplos y les recomiendo estudiar bastante el tema ya que con un buen dominio de él podremos sacarle mejor partido a las consultas en nuestra base de datos.

(Obtener el mayor código de los productos de la categoría Lácteos)
                var productos = (from c in productosContext.Productos
                    from e in c.Categorias
                    where e.Nombre.Contains("Lacteos")
                    select c).Max(f => f.Codigo);

Adicional aquí pueden encontrar todos los operadores y funciones:
Ejemplos consultas linq y operadores.

Y para realizar la primera consulta a través de lambda sería:

     var producto = productosContext.Productos.FirstOrDefault(c => c.Codigo == 1);

como podemos ver mucho más sencilla y en una sola línea de código. Lambda nos permite hacer mucho más simples las consultas y ahorrar bastantes líneas de código, aquí les comparto algunos ejemplos: expresiones lambda.

En conclusión sea cual sea el método de consulta que usemos, lo que hará internamente Entity Framework es convertir estas instrucciones en sentencias Transact Sql (A no ser que tengamos mapeada nuestra entidad a un procedimiento almacenado, lo cual veremos más adelante) y ejecutarlas en nuestro motor de base de datos, el cual nos da una respuesta y EF de nuevo la convertirá en términos de nuestra entidad.


Realizando operaciones de inserción, actualización y eliminación:

Para realizar operaciones de inserción debemos crear una nueva instancia de nuestra entidad representada en la base de datos, es igual a lo que estamos acostumbrados, totalmente objetual, sólo creamos la instancia y establecemos las propiedades que queremos persistir y luego hacemos un add sobre el la entidad, con esto agregamos el registro, pero aun debemos hacer el commit para que se asiente la instrucción y esto lo hacemos a través del método SaveChanges() de nuestro contexto, esto se requiere para cualquier transacción y nos ofrece la ventaja de hacer múltiples operaciones sobre una sola transacción.

            using (var productosContext = new ProductosContext())
            {
                var producto = new Producto
                {
                    Codigo = 7,
                    Nombre = "Yogurt"
                };
                productosContext.Productos.Add(producto);
                productosContext.SaveChanges();
            }

Por otro lado para actualizar y eliminar cómo es obvio antes debemos realizar una consulta, para que EF se entere de que registro deseamos tratar, entonces podemos hacer una consulta especifica como vimos anteriormente, y posteriormente actualizar alguna propiedad de la entidad o simplemente eliminarla, veamos un ejemplo de cómo hacerlo.

            using (var productosContext = new ProductosContext())
            {
                var producto = productosContext.Productos.First(c => c.Codigo == 7);
                producto.Nombre = "Yogurt dietético";
                productosContext.SaveChanges();
            }

Y para eliminar

            using (var productosContext = new ProductosContext())
            {
                var producto = productosContext.Productos.First(c => c.Codigo == 7);
                productosContext.Productos.Remove(producto);
                productosContext.SaveChanges();
            }

Trabajando con datos relacionales: (consulta y transacción)

Una de las grandes ventajas de un ORM es que podemos trabajar con nuestros datos relacionales sin ningún problema, es decir, podemos en una consulta traer por demanda o por defecto (tema que veremos a continuación) datos de otras tablas relacionadas, o también podemos crear una entidad con entidades anidadas que representen otras tablas y guardar en una sola transacción, ya que Entity Framework se encarga de almacenar en cada una de las tablas, enviándole tan sólo la entidad principal, veamos cómo funciona esto que acabo de mencionar:

Consultando información relacionada:

A través de la cláusula Include, podemos indicar a Entity Framework que nos retorne la información de otras entidades relacionadas, este comportamiento está activado por defecto en Entity Framework y es lo que conocemos como Eager Loading. Veamos cómo lo podemos hacer:



Almacenando información relacionada:

Para almacenar información relacionada, tenemos una gran ventaja y es que podemos guardar todo en una sola transacción sin tener que construir entidad por entidad, y hacer inserción para cada una, es decir podemos crear una sola entidad con anidamiento y listo, observemos como se hace:

            using (var prodcutosContext = new ProdcutosContext())
            {
                var producto = new Producto
                {
                    Codigo = 22,
                    Nombre = "cereal",
                    Categorias = new Collection<Categoria>
                    {
                        new Categoria
                        {
                            Nombre = "Cereales",
                            Descripcion = "Productos de cereal"
                        }
                    }
                };
                prodcutosContext.Productos.Add(producto);
                prodcutosContext.SaveChanges();
            }

Como podemos ver creamos un nuevo producto y a la vez creamos una nueva categoría, Entity Framework se encarga de guardar en las respectivas tablas, incluyendo la tabla de la relación.

Eager Load vs Lazy Load:

Como mencioné anteriormente a través de Entity Framework podemos obtener fácilmente datos de otras entidades relacionadas, pero siempre traer datos de entidades relacionadas a una determinada entidad sería bastante costoso, aun sabiendo que no siempre requeriremos del uso de esto. Es por esto que Entity Framework nos ofrece la posibilidad de trabajar de dos formas con respecto a esto, una de ellas es Eager load que nos permite cargar todas las entidades relacionadas que indiquemos, esto suele ser costoso ya que hacemos carga de todo y más aun si se trata de un IEnumerable ya que por cada ítem cargaríamos sus entidades relacionadas, por lo tanto se debe ser cuidadoso al usar este tipo de carga, como todo tiene escenarios donde aplica perfecto y otros dónde no es buena idea usarlo. Y por otro lado tenemos Lazy Load, que nos permite una carga por demanda, es decir solo se consultan datos relacionados en el momento en que se requieran, por ejemplo si hacemos alusión a una entidad relacionada en ese momento se hará la consulta y no una vez se consulte la principal como pasa en Eager Load. Entonces tenemos estas dos opciones y cómo ya vimos anteriormente a través de la cláusula Include, podemos indicar a Entity Framework que nos retorne los datos de las entidades relacionadas, ahora para evitar que EF siempre retorne por defecto la información de todas las entidades relacionadas debe establecer la siguiente configuración en nuestro contexto:

        public ProdcutosContext()
            : base("name=ProdcutosContext")
        {
            this.Configuration.LazyLoadingEnabled = false;
        }

Recordemos que no se trata de que una opción sea mejor que la otra, si no de saber usar la opción adecuada según el escenario en el que nos encontremos, por ejemplo si sabemos siempre que debemos mostrar todos los ítemes de una lista al igual que sus sub ítemes entonces será una buena opción usar Eager loading, para obtener en una sola consulta toda la información requerida, pero si hay un escenario dónde sabemos que debemos mostrar solo sub ítemes por demanda, es decir solo si se llega a seleccionar el ítem principal, entonces es buena idea usar Lazy loading.

Bueno amigos eso es todo de este ejemplo de cómo interactuar con nuestro contexto en Entity Framework, espero les sea de utilidad y de interés.

Saludos, y buena suerte!

martes, 22 de abril de 2014

Desplegando nuestros sitios MVC en Azure Web Sites

Hola amigos en nuestro artículo anterior, utilizando Sql Azure y Entity Framework vimos cómo crear nuestro modelo conceptual de EF a partir de una base de datos existente en Sql Azure, es decir en la nube, y para probar cómo funcionaba nuestro ejemplo y cómo interactuaban estas dos tecnologías creamos un sitio web con MVC. Ahora en este artículo vamos a aprender cómo desplegar o publicar nuestro sitio web en Azure Web Sites, y como es de costumbre en mis artículos voy a iniciar dando una breve introducción acerca de esta tecnología.

Azure Web Sites:

Es un hosting para sitios web en la nube, brindado por Microsoft Azure, que nos permite múltiples ventajas contra el hosting en alguno de nuestro servidores, como por ejemplo, la administración y mantenimiento de los servidores por parte de Microsoft, garantía de máxima disponibilidad, replicación, auto escalamiento, manejo de seguridad, fácil monitoreo, entre otras. Para mayor información pueden visitar este link Microsoft Azure Web Sites.

Ahora sí, después de esta breve introducción vamos a ver cómo desplegar nuestro sitio implementado en MVC en Azure Web Sites. Existen varias formas de hacerlo, a través de un repositorio Git, a través de un cliente ftp o a través de Visual Studio, nosotros nos vamos a centrar en esta última.

En primera instancia hacemos clic derecho sobre nuestra aplicación web y elegimos la opción publicar:


Posteriormente elegimos la opción de despliegue "Windows Azure Web Sites":


A continuación podemos elegir un sitio web de Azure existente, si es que ya lo creamos previamente a través del administrador de Microsoft Azure, o si no lo tenemos aún como es nuestro caso podemos crear uno nuevo de inmediato:


Para esto debemos autenticarnos con nuestra cuenta Microsoft que tenga permisos en Microsoft Azure


Y configurar los datos de nuestro sitio


En nuestro caso por ejemplo vamos a usar la base de datos creada en nuestro artículo anterior Sql Azure y Entity Framework, en caso tal que el sitio no necesite una base de datos podemos elegir la opción "None". Luego de esto debemos confirmar los datos de conexión los cuales podemos verificar a través del botón "Validate Connection".


Adicional podemos editar la configuración de nuestra publicación como publicación en Debug o Release, cadenas de conexión, en nuestro caso tenemos dos, una por defecto y la otra para nuestra base de datos de ejemplo, y entre otras configuraciones.


Para terminar con este proceso de publicación tenemos la vista previa de los archivos que se publicarán en el sitio del cual podemos excluir archivos si lo queremos y además incluir despliegues de base de datos.


Y si hacemos clic en el botón "Publish" y esperamos algunos segundos, veremos nuestro sitio implementado en Asp.Net MVC hospedado en un sitio de Microsoft Azure.


Bueno amigos eso es todo de este ejemplo de cómo desplegar nuestros sitios web MVC en Microsoft Azure Web Sites, espero les sea de utilidad y de interés.

Saludos, y buena suerte!

domingo, 13 de abril de 2014

Utilizando Sql Azure y Entity Framework

Hola amigos, en esta ocasión vamos ver cómo usar Entity Framework con una base de datos en la nube, más específicamente Sql Azure, vamos a ver cómo interactúan estas dos tecnologías, para esto vamos a crear nuestra base de datos Sql Azure, y luego vamos a crear nuestro modelo en Entity Framework usando el enfoque Data Base First y por último vamos a crear un sitio web con Asp.Net MVC para ver cómo funciona.

Antes de iniciar me parece oportuno hablar un poco acerca de Sql Azure:

Sql Azure: Base de datos relacional hospedada en la nube, basada en sql server, permite alta escalabilidad y automatización, garantiza alta disponibilidad, mantenimiento y actualización garantizado y ejecutado por Microsoft.

Ahora iniciemos creando nuestra base de datos en Sql Azure, para esto ingresamos a nuestro administrador de Microsoft Azure y elegimos la opción "Base de datos Sql":


Posteriormente hacemos clic en la opción "Nuevo" señalada en la imagen anterior, con la cual se nos mostrará la siguiente pantalla:


Allí elegimos la opción de creación rápida, en la cual solo debemos especificar el nombre de la base de datos y el servidor en el cual se creará o si deseamos podemos crear un nuevo servidor, para nuestro ejemplo llamaremos la base de datos "DemoEfSqlAzure" y elegiremos la opción de crear nuevo servidor, para lo cual debemos seleccionar una región de ubicación del servidor, un nombre de inicio de sesión y una contraseña y para terminar la creación hacemos clic en el botón "Crear base de datos Sql".

Ahora que tenemos nuestra base de datos creada la vamos a seleccionar y elegir la opción "Administrar", de inmediato se nos muestra en siguiente mensaje:


Es importante elegir la opción "Si" para que se agregue la excepción en el Firewall de este modo podamos acceder a nuestra base de datos de manera remota. Posteriormente se abre la consola de administración de la base de datos en la cual podemos agregar, modificar, eliminar tablas, modificar su estructura y demás operaciones en la base de datos.

Posteriormente vamos a crear una nueva tabla en nuestra BD llamada estudiantes:


Ahora que tenemos nuestra base de datos el siguiente paso es crear nuestro modelo en Entity Framework basado en ella, y para esto vamos a abrir nuestro excelente IDE Visual Studio y vamos a crear un nuevo proyecto de tipo librería:


y una vez creado el proyecto hacemos clic derecho sobre él y elegimos la opción agregar nuevo ítem, filtramos por ítems tipo datos y elegimos Ado.Net Entity Data Model y elegimos la opción agregar, y ahora se inicia el asistente para la creación de nuestro modelo conceptual, en el cual elegiremos el enfoque "Ef designer from DataBase" del cual hemos hablado en artículos anteriores.


Ahora debemos suministrar los datos de conexión a nuestra base de datos en la nube, más específicamente los siguientes:


El nombre del servidor lo podemos tomar de nuestro sitio de administración de Sql Azure, seleccionando nuestra base de datos y observando la sección de conexión a la base de datos, tal y cómo se muestra en la siguiente imagen:


Posteriormente probamos que nuestra conexión esté funcionando correctamente, seleccionamos la versión de Entity Framework con la que vamos a trabajar, en nuestro caso la 6.0, y por ultimo seleccionamos los objetos de la base de datos que queremos mapear:


Perfecto, ahora tenemos listo nuestro modelo conceptual en Entity Framework mapeado a nuestra base de datos en la nube, ahora para terminar nuestro ejemplo vamos a crear en la misma solución de Visual Studio un nuevo proyecto web Asp.Net MVC desde el cual vamos a consumir nuestro modelo conceptual de EF para probar su funcionalidad.

En primera instancia en nuestro proyecto de MVC vamos a referenciar nuestra librería creada anteriormente para lograr ver nuestro contexto, luego compilamos la solución y además vamos a copiar en el web.config la cadena de conexión que tenemos en el app.config de dicha librería, esto para lograr conectarnos a la base de datos desde nuestra aplicación web.

Y para terminar vamos a hacer clic derecho sobre la carpeta Controllers de nuestra aplicación web y vamos a elegir la opción "agregar controlador", y vamos a elegir la plantilla "MVC 5 Controller with views, using Entity Framework" lo que nos generará todas nuestras vistas y nuestro controller con las acciones Crud básicas las cuales usan el contexto para acceder a nuestra base de datos en la nube:



Si esperamos unos segundos veremos que Visual Studio nos genera nuestras vistas y nuestro controlador, en el cual sus acciones básicas usan el contexto de Entity Framework para interactuar con la base de datos. Nuestra acción para obtener todos los estudiantes por ejemplo:


Y si ejecutamos nuestra aplicación por fin veremos que interactuamos correctamente con nuestra base de datos Sql Azure a través de Entity Framework  y que podemos hacer operaciones básicas con nuestra tabla estudiantes a través de nuestra aplicación Asp.Net MVC.


Bueno amigos eso es todo de este ejemplo de cómo conectarnos a una base de datos Sql Azure desde Entity Framework, espero les sea de utilidad y de interés.

También puedes ver este vídeo donde explico paso a paso como hacerlo también, solo que esta vez usando el enfoque CodeFirst: Vídeo, usando EntityFramework y Sql Azure.

Saludos, y buena suerte!

martes, 8 de abril de 2014

[EntityFramework] Nueva funcionalidad Code First, Update Visual Studio 2013 2 RC

Hola amigos, como todos sabemos recientemente se presentó el Microsoft Build 2014, en el cual entre otras cosas se presentaron grandes avances en las diversas tecnologías Microsoft, cómo por ejemplo Windows 8.1, Windows Phone 8.1, Microsoft Azure, Visual Studio, etc. Y entre las actualizaciones para Visual Studio 2013 encontramos algo bastante interesante en cuento a Entity Framework se refiere, y es el hecho de poder trabajar con el enfoque Code First teniendo en primera instancia nuestra base de datos, y lo mejor de esto, sin tener que usar los power tools que solemos usar para lograr esto, entonces a través de esta nueva funcionalidad de VS podemos crear en primera instancia nuestra base de datos y posteriormente podemos generar nuestro modelo Code First a partir de ella, bastante bueno para los que preferimos este enfoque de EF, ya que ahora podemos crear y modelar nuestra BD como estamos acostumbrados y luego vamos a tener todo el dominio de nuestro modelo conceptual como preferimos, y todo esto soportado nativamente por  nuestro invaluable IDE Visual Studio.

Pero bueno veamos en acción esta nueva actualización, y lo primero que les recomiendo es descargar el Update Visual Studio 2013 2 RC y una vez lo tengan instalado podrán observar esta nueva opción de la que estamos hablando.

Ahora para iniciar vamos a crear un nuevo proyecto de tipo librería de clases, como se muestra a continuación:


Una vez creada nuestra librería de clases, vamos a hacer clic derecho sobre ella y vamos a elegir la opción "Agregar nuevo ítem", y vamos a elegir el tipo de ítem "ADO.NET Entity Data Model":


Ahora viene la novedad, veremos que tenemos habilitada la nueva opción "Code First From Data Base" la cual seleccionaremos para ver que viene a continuación:


Lo que viene a continuación es similar a lo que estamos acostumbrados cuando usamos el enfoque Data Base First, es decir generar una conexión a la base de datos y seleccionar los elementos de esta a mapear:



Todo muy sencillo como es de costumbre. Y por último si finalizamos el asistente y esperamos algunos segundos veremos que se generaran todas nuestras clases POCO y obviamente nuestro contexto usando Code First y usando una combinación de Data Anottations y Fluent Api para configurar nuestras entidades.

Bueno amigos eso es todo de este acercamiento a esta actualización recientemente liberada para Entity Framewor Code First, espero les sea de utilidad y de interés.

Saludos, y buena suerte!