[EntityFramework] Agregando propiedades y metadatos a nuestras clases autogeneradas en DB First

Hola amigos, ya que estamos dando por terminada esta serie de post sobre Entity FrameWork no quería dejar a un lado una importante característica que debemos conocer cuando trabajamos con el enfoque Data Base First y que seguro vamos a necesitar en cualquier proyecto en el que usemos este enfoque, y quiero antes que nada plantearles una necesidad para que comprendan con mayor facilidad la utilidad del tema que vamos a tratar en este artículo:

"Recordemos que un principio que debemos tener presente como desarrolladores es, nunca debemos modificar código autogenerado puesto que una vez se vuelva a autogenerar por cualquier motivo, perderemos los cambios que hicimos en el archivo en cuestión"

Bueno, ahora teniendo clara esta premisa, por si aún no se habían topado con algún caso de este tipo, surgen un par de interrogantes cuando trabajamos con Entity Framework DataBase First y son las siguientes:

1. ¿Cómo puedo yo entonces agregar propiedades a mi entidad de domino directamente que no necesariamente quiero que persistan a mi base de datos?
2. ¿Cómo puedo yo agregar metadata (Atributtes Data Anottations) adicional a mis entidades de domino?

Pues bien, creo que con estas dos interrogantes ya nos queda claro cuál es la necesidad de usar clases parciales para extender nuestras entidades autogeneradas. Ahora veamos como lo podemos lograr.

En primera instancia vamos a crear un modelo de Entity Framework usando el enfoque DataBase First el cual podemos observar en detalle en este artículo:  Creando nuestro modelo conceptual con DataBase First y como es normal veremos que se autogeneran nuestras entidades con todos sus metadatos, a este código es el que me refiero, no se puede modificar!

En nuestro caso se generó la entidad producto, como vemos a continuación. Si leemos el comentario en el encabezado de la clase veremos que se advierte de las consecuencias de modificarla:

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from a template.
//
//     Manual changes to this file may cause unexpected behavior in your application.
//     Manual changes to this file will be overwritten if the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
 
namespace DataBaseFirstDemo.Dominio
{
    using System;
    using System.Collections.Generic;
    
    public partial class Producto
    {
        public Producto()
        {
            this.Categorias = new HashSet<Categoria>();
        }
    
        public string Nombre { get; set; }
        public int Codigo { get; set; }
    
        public virtual ICollection<Categoria> Categorias { get; set; }
    }
}

Ahora bien, que tal si queremos agregar una nueva propiedad a la entidad en la cual podamos obtener el código y el nombre del producto en una sola cadena? para esto creamos una nueva clase parcial llamada producto, la cual debe tener el mismo NameSpace que la clase producto autogenerada, y cabe aclarar algo, el archivo .cs debe tener un nombre diferente a Producto.cs, pero la clase en su interior debe tener el nombre de Producto, para que el FrameWork las trate como una sola. Tal y como vemos a continuación:

Como podemos ver tenemos las dos clases que físicamente son diferentes, es decir en dos archivos diferentes pero lógicamente son una sola, ya que desde la clase que hemos creado podemos ver las propiedades Codigo y Nombre que fueron autogeneradas.

Bastante sencillo, ahora vamos a ver cómo podemos agregar metadata adicional a las propiedades autogeneradas. Ya que como sabemos Entity Framework genera la metadata que obtiene desde la base de datos, como la longitud del campo, constrains y demás.

Lo primero que debemos hacer es crear una clase que puede estar en el interior del archivo Producto.cs que creamos nosotros y la podemos llamar ProductoMetaData, en la cual vamos a replicar todas aquellas propiedades a las cuales queremos agregar metadata adicional, en nuestro caso vamos a replicar la propiedad Nombre, para especificar que es requerida y que solo debe permitir una longitud máxima de 4 caracteres:

using System.ComponentModel.DataAnnotations;
 
namespace DataBaseFirstDemo.Dominio
{
    [MetadataType(typeof(ProductoMetaData))]
    public partial class Producto
    {
        public string InformacionProducto
        {
            get
            {
                return string.Format("{0} - {1}", this.Codigo, this.Nombre);
            }
        }
    }
 
    public class ProductoMetaData
    {
        [Required, MaxLength(4)]
        public string Nombre { get; set; }
    }
}

Y para finalizar debemos indicar que esta clase de metadata va a ser usada por nuestras clase Producto, y lo hacemos decorando nuestras clase con el atributo MetadataType e indicando la clase de metadata que acabamos de crear, tal y como se ve en el fragmento de código anterior.

Bueno amigos eso es todo de esta muestra de cómo agregar propiedades y metadata adicional a nuestras entidades autogenradas en DataBase First, espero les sea de utilidad y de interés. Y no duden en compartirlo.

Saludos, y buena suerte!

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!

[EntityFramework] Resumen DataBase First

Hola amigos, les comparto el resumen de todo lo que aprendimos en esta serie de artículos acerca de Entity Framework DataBase first, espero les sea de utilidad:

Enfoques en Entity Framework

• Conocimos los tres enfoques que tenemos en Entity Framework, DataBase first, Model first y code first, y tuvimos un punto de referencia para elegir uno de ellos.

Iniciando con DataBase first

• Aprendimos a crear nuestro modelo conceptual a partir de nuestra base de datos.

Míralo tan fácil como quieras! dividiendo en colores tu modelo conceptual

• Vimos una característica que nos facilita mucho el entendimiento de nuestro modelo conceptual como lo es la división en diferentes colores.

Divide y vencerás! dividiendo en varios modelos nuestro modelo conceptual

• Aprendimos a dividir nuestro modelo conceptual en varios sub modelos, con el fin de organizarlo mejor y facilitar su entendimiento y manejo.

Actualizando nuestro modelo cuando surgen cambios en la base de datos

• Hicimos un ejemplo de cómo actualizar nuestro modelo cuando surgen cambios en la base de datos.

No tienes por qué dejar tus procedimientos almacenados en el olvido, úsalos en EF

• Conocimos las formas de cómo trabajar con procedimientos almacenados en EntityFramework.

Trabajando con enumeraciones

• Observamos el soporte para manejo de enumeraciones que nos ofrece Entity Framework.

Usando datos Geoespaciales

• Y para terminar observamos el soporte para trabajar con datos geoespaciales que nos brinda Entity Framework.

Saludos y buena suerte!

[EntityFramework] Usando datos Geoespaciales

Una de las principales características introducidas en Sql Server 2008 fue el soporte para trabajar con datos geoespaciales, a  través del soporte para los tipos Geography y Geometry, y una buena pregunta sería, ¿podemos trabajar en EntityFramework con estos tipos de datos? pues bueno la repuesta es si, a partir de la versión 5 de EF esta característica fue liberada, con soporte para ambos tipos, y es de gran utilidad, ya que quizás podía significar una limitante a la hora de decidir usar como ORM EntityFramework, si nuestro sistema iba a trabajar con este tipo de información, pero bueno veamos en el listado de tipos de datos de EF como aparecen estos tipos de datos:

Como podemos ver, para ambos se muestran los mismos tipos respectivamente, y creo que hasta aquí surge otra interrogante, ¿Cuál es la diferencia entre Geography y Geometry entonces? respondamos a esta pregunta definiendo cada uno:

Geography: Tipo de dato espacial que tiene la capacidad de almacenar datos elipsoides como lo son por ejemplo la coordenadas de latitud y longitud.

Geometry: Tipo de dato espacial que tiene la capacidad de almacenar un sistema de coordenadas plano.

Y adicional cito esta definición:

Geometry and Geography are a bit different. Geometry deals with planar data. Geometry is well documented under the Open Geospatial Consortium (OGC) Specification. Geography deals with ellipsoidal data, taking in mind the curvature of the earth when performing any calculations. SQL introduced spatial support for these two types in SQL Server 2008. The SQL implementation supports all of the standard functions outlined in the OGC spec.

Y  bueno amigos eso es todo, espero les sea de utilidad y puedan tener un recurso del cual echar mano cuando se les presente algún requerimiento en algún sistema con respecto a manejo de información espacial.

Adicional les quería compartir estas referencias, por si quieren profundizar más acerca del tema:

• Tipos espaciales en EntityFramework
• Spatial types in the EntityFramework

Saludos y buena suerte!

[EntityFramework] Trabajando con enumeraciones

Sin lugar a duda, un recurso ofrecido por el .Net Framework y muy utilizado por todos son las famosas enumeraciones o enum, que básicamente son un conjunto de constantes con nombre, que nos permite hacer nuestro código más legible y organizado, además de evitar confusiones con respecto a los valores que admite determinada variable, y sin dejar a un lado la ventaja de poder usar el Intellisense para la asignación de valores. Para mayor detalle observar msdn Enum referencia.

Y bueno el uso entonces de los enums, en la mayoría de los casos supone también que se debe persistir su valor en la base de datos, y que bien que nuestro ORM pudiera manejar por si solo el trabajo con enumeraciones, sin que esto implique esfuerzo alguno para el desarrollador ¿no creen? Pues bueno a partir de la versión 5 de EntityFramework se incorporó el soporte de enumeraciones, y vaya que es una gran característica, ya que podemos trabajar con el tipo del enum como estamos acostumbrados a través de una propiedad de nuestra entidad, y EF se encarga de mapear su valor y guardarlo en la base de datos, y a continuación vamos a ver cómo podemos lograrlo:

Lo primero que debemos hacer es abrir nuestro modelo, y abrir el Model Browser, en el cual encontraremos una carpeta llamada Enum types, sobre la cual haremos clic derecho y elegiremos la opción "Add New Enum type", tal como se muestra en la imagen:

Enseguida se nos mostrara la siguiente ventana, en la cual debemos especificar las constantes que tendrá nuestra enumeración:

En primera instancia debemos especificar el nombre que tendrá la enumeración, y el tipo del cual heredara si Int 16, 32 ó 64, Byte o SByte esto según la longitud de los números que se vayan a asignar a las constantes. Y posteriormente debemos indicar cuál será el listado de constantes de la enumeración y que valor le corresponderá a cada una, y ya con esta información podemos terminar la creación del enum, sin embargo en la última parte del cuadro de dialogo tenemos dos opciones más, las cuales explicaré a continuación:

Set Flags attribute: Como todos sabemos o si no lo sabes aún te contextualizo, cuando creamos a través de código una enumeración la podemos decorar con el atributo [Flags], esto indica que la enumeración podrá manejar combinaciones, es decir se puede asignar su valor con más de una opción, yo podría asignar como valor, en nuestro caso por ejemplo los valores TarjetaCredito y TarjetaDebito que en código C# sería algo como esto:

FormaPago formPago = FormaPago.TarjetaCredito | FormaPago.TarjetaDebito;

Reference external type: Además de crear una nueva enumeración también podemos usar una ya existente, para eso este campo, en el cual debemos especificar el NameSpace y el nombre del enum, para que sea usado por EntityFramework.

Y listo para crear nuestra enumeración oprimimos el botón OK, y ya tenemos nuestro enum creado para ser utilizado, ahora podemos hacer clic en cualquiera de los campos de cualquier entidad y abrimos el cuadro de propiedades correspondiete(F4) y en el campo "type" veremos que ya podemos escoger como tipo la enumeración que acabamos de crear:

Bueno y con esto damos por terminado nuestro artículo acerca del cómo trabajar con enumeraciones en EntityFramework, espero les sea de gran utilidad y ya queda criterio propio como explotar todas las ventajas que nos ofrece.

Saludos y buena suerte!

[EntityFramework] No tienes por qué dejar tus procedimientos almacenados en el olvido, úsalos en EF

En nuestra serie de post acerca de DataBase First hemos visto varios artículos que nos guían sobre como interactuar con nuestro modelo y nuestra base de datos, y sin lugar a dudas no podemos dejar a un lado el uso de procedimientos almacenados, ya que es un objeto de nuestra base de datos al que estamos bastante acostumbrados y solemos usar a menudo, por esto vamos a dar un vistazo a como se usan en EntityFramework.

Antes que nada para hacernos una idea más global de cómo se usan los stored procedures en EntityFramework cabe decir que se mapean a nuestro modelo como funciones o métodos, los cuales podemos usar normalmente con C# o el lenguaje de programación con el que estemos trabajando explícita o implícitamente, entonces podemos usar de igual forma parámetros de entrada y de salida, que es una técnica bastante utilizada por todos, y como es de esperarse también podremos obtener un valor de retorno en nuestro método. Pero bueno ahora sí, veamos como agregar procedimientos almacenados que existen en nuestra base de datos a nuestro modelo.

Existen varias formas de hacerlo, y vamos a verlas a continuación:

Mapear un procedimiento almacenado a una entidad en específico:

En nuestro modelo podemos hacer clic sobre una de las entidades y elegir la opción "Estored Procedure Mapping", esto implica que el procedimiento será mepado directamente a nuestra entidad, y que cuando hagamos una actualización, inserción o eliminación (Depende de las que funciones que indiquemos) sobre la entidad, el código que generará EF cuando usemos Linq no será un query como habitualmente lo hace si no que generará el llamado al procedimiento almacenado enviando los parámetros indicados.

Enseguida se nos muestra la pestaña de "Mapping Detailts" en dónde encontraremos tres secciones, una para mapear un procedimiento para inserción, otra para mapear un procedimiento de actualización y por ultimo una para mapear un procedimiento de eliminación, podemos usarlas todas o solo las que necesitemos según sean nuestras necesidades, y cuando elijamos el SP que deseamos mapear enseguida se desplegarán sus parámetros y adicional podemos especificar bindings para los resultados, tal y como se muestra en la siguiente imagen:

Para terminar de mapear nuestro procedimiento almacenado, guardamos los cambios realizados en el modelo y listo! ahora podemos ver el SP mapeado como una función en el Model Browser:

Mapear una función a un procedimiento almacenado:

También podemos mapear una función de EF a un procedimiento almacenado directamente, y podemos manejar varios valores de retorno, para esto debemos hacer clic derecho sobre nuestro modelo sin tocar una entidad y elegir la opción "Add New" / "Function Import" tal y como se muestra en la imagen:

Enseguida se nos mostrará la siguiente ventana que describo a continuación:

Como vemos en primera instancia debemos especificar el nombre que va a tener nuestra función, debajo tenemos una casilla de verificación "Function import is composable", que nos permite indicar si vamos a trabajar con un SP o con una función de sql server, y dependiendo de esta selección en el siguiente listado se mostraran todos procedimientos almacenados o todas las funciones que tengamos en nuestra base de datos, obviamente debemos seleccionar una. Ahora vamos a ver que opciones tenemos para retornar en nuestra función:

None: Indica que la función no tendrá valor de retorno.

Escalars: Indica que la función retornara un valor escalar, es decir un solo valor, el cual puede ser de diversos tipos los cuales podemos ver si seleccionamos esta opción.

Complex: Indica que la función retornara un tipo complejo o Complex type, de este tipo hablaremos más adelante, pero básicamente es un tipo que puede contener campos de varias entidades por ejemplo, o incluso campos que no corresponden a las entidades como valores calculados, si seleccionamos esta opción podemos seleccionar un tipo complejo que ya tengamos creado, o también lo podemos crear en esta misma ventana a través de la opción "Create new Complex Type" que explicaré más adelante.

Entities: Indica que se va a retornar una entidad de nuestro modelo.

Y por último tenemos la sección de información de columna, donde si hacemos clic en la opción "Get Column Information" podremos ver el detalle de cada columna que devuelve el procedimiento almacenado, si es que devuelve alguna columna, y es a esto cuando me refería a crear un Complex type desde esta misma ventana, ya que si hacemos clic en la opción "Create new Complex Type" automáticamente se creará un tipo complejo para la estructura de columnas que devuelve el SP.

Mapear la función al procedimiento almacenado a través del Model Browser:

Bueno y por ultimo también podemos hacer el mapeo del procedimiento almacenado desde el model browser, haciendo clic derecho en la carpeta "Function Imports" y eligiendo la opción "Add function import", tal y como se ve en la imagen:

Y posteriormente se nos muestra la misma ventana explicada anteriormente.

Bueno y con esto damos por terminado nuestro artículo acerca del uso de procedimientos almacenados en EntityFramework, espero les sea de gran utilidad y veamos que no se trata de comparar EF vs Stored procedures como me han preguntado algunas personas, si no de usarlos en conjunto para obtener un óptimo desempeño.

Saludos y buena suerte!

[EntityFramework] Actualizando nuestro modelo cuando surgen cambios en la base de datos

Como es normal, una vez creada la base de datos de nuestro proyecto, lo más probable es que surjan muchos cambios que debamos hacer sobre ella. ya sea porque descubrimos alguna inconsistencia, por cambios del sistema o por que simplemente se agregan nuevas funcionalidades o módulos, bueno esto de entrada nos hace plantearnos una interrogante, Si ya tengo mi modelo con EF ¿cómo logro actualizar los cambios desde mi base de datos? bueno esto es algo sumamente sencillo y que ha venido mejorando en EntityFramework, como en nuestra serie de artículos sobre EF vamos a ver un paso a paso de cómo lograr esto:

En primera instancia debemos tener abierto nuestro modelo y sobre el hacer clic derecho y elegir la opción "Actualizar modelo desde la base de datos", como se ve en la imagen:

Con esto se nos abrirá una ventana que contiene tres pestañas la primera con título agregar, la segunda actualizar y la tercera eliminar, y como su nombre lo indica en la pestaña agregar encontramos todos los elementos que se han agregado a la base de datos y que aún no están mapeados a nuestro modelo o aquellos objetos que no se seleccionaron cuando se decidió crear el modelo basado en la DB:

En la segunda pestaña encontraremos todo aquellos objetos que se actualizarán con la sincronización, es decir aquellos que ya están mapeados con la base de datos, se actualizarán para obtener cambios que aún no se han mapeado:

Y por último en la tercer pestaña encontramos todos aquellos objetos que se decidieron eliminar de nuestro modelo, esto quiere decir que los elementos que seleccionemos en esta pestaña se borraran también de la base de datos, por eso debemos tener especial cuidado con esta pestaña, ya que pudimos haber eliminado alguna entidad de nuestro modelo sin darnos cuenta:

Bueno y para efectuar la sincronización hacemos clic sobre el botón "Terminar", esperamos unos segundos y enseguida podemos ver todos los cambios que realizamos en la base de datos actualizados en nuestro modelo.

Y eso es todo, una manera bastante simple y ágil para sincronizar nuestro modelo con nuestra base de datos, espero les sea de utilidad.

Saludos y buena suerte!

[EntityFramework] Divide y vencerás! dividiendo en varios modelos nuestro modelo conceptual

Como vimos en nuestro anterior artículo, veíamos una forma que nos ofrece Entityframework a través de colores para hacer más legible nuestro diagrama a la hora de interpretarlo y analizarlo, sobre todo cuando nuestro modelo es demasiado grande y complejo, pero esto no es todo, hay otra facilidad que nos ofrece EF y es separar nuestro modelo en varios diagramas para visualizarlo mejor, esto no quiere decir que vamos a separar nuestro modelo y sus clases generadas y ahora tengamos que acceder de forma diferente a ellas, es solo una separación visual valga la aclaración. Entonces una buena practica sería tener un diagrama principal en el cual tengamos nuestro modelo completo, y tener sub diagramas que nos modelen ciertas incumbencias del negocio, entonces podríamos tener un sub diagrama para ventas, otro para clientes, otro para proveedores y así, según lo necesitemos. Pero bueno veamos cómo podemos hacer esto en la práctica:

Lo primero que debemos hacer es clic derecho sobre nuestro modelo y elegir Model Browser, con esto se nos despliega una pestaña en cual podemos ver los diagramas, las entidades del modelo y la base de datos.

Ahora en la carpeta Diagrams hacemos clic derecho y elegimos la opción "add new Diagram", con esto tenemos una plantilla en blanco, sobre la cual podemos arrastrar todas nuestras entidades para formar el diagrama que queremos.

De esta forma podemos crear los diagramas que queremos y podremos comprender y tener mayor enfoque cuando requiramos analizar el modelo correspondiente a alguna parte en específico de nuestro sistema, adicional hay una característica que vale la pena resaltar y es que si hacemos clic derecho sobre una de las entidades y elegimos la opción: "Include Related" se nos traerán al diagrama todas las entidades que tienen relación con esta, muy útil por cierto para formar el diagrama con mayor rapidez.

Y para finalizar quisiera recomendarles tener precaución al eliminar una entidad de algún diagrama, ya que si no nos fijamos bien podemos eliminar la entidad como tal de nuestro modelo, es decir eliminar la clase y cuando sincronicemos con la base de datos eliminaríamos la tabla, y hablo de cuando la eliminamos a través de la tecla suprimir, entonces les recomiendo usar shift + suprimir, si lo quieren hace por teclado o haciendo clic derecho sobre la entidad y eligiendo la opción "Remove from diagram".

Y bueno eso es todo por hoy, espero que les sea de gran utilidad para ordenar y hacer más legibles sus diagramas.

saludos y buena suerte!

[EntityFramework] Míralo tan fácil como quieras! dividiendo en colores tu modelo conceptual

Como todos sabemos, en proyectos de gran tamaño, también tenemos por lo general un modelo de datos de gran tamaño, y que tiende a crecer con el tiempo, esto sin lugar a dudas se vuelve demasiado engorroso a la hora de comprender el diagrama y a la hora de buscar tablas y relaciones que corresponden a cierta incumbencia del sistema. Pero bueno, después del problema ahora veamos una de las soluciones que nos plantea EntityFramework al respecto:

En EF podemos hacer mucho más amigable visualmente nuestro modelo, pintándolo y dividiéndolo por colores, por ejemplo podríamos colorear de verde las tablas correspondientes a seguridad, o de naranja las tablas correspondientes a las ventas y así para cada segmento de tablas, ahora veamos cómo podemos hacer esto y que tan sencillo es:

Solo basta con elegir la tabla o las tablas que deseamos pintar de cierto color, abrimos el cuadro de propiedades(f4) y establecemos la propiedad FillColor seleccionando del ColorPicker el color que queremos, y así para cada tabla, de esta forma nos encontramos con un modelo divido y agrupado estratégicamente y de mucha más fácil compresión. Eso es todo, espero que este sencillo truco les sea de utilidad a la hora de ordenar mejor su modelo.

saludos!

[EntityFramework] Iniciando con Data Base First

En el artículo anterior Enfoques en EntityFramework observamos que enfoques o que flujos podemos seguir para trabajar con EF, ahora vamos a hacer doble clic sobre cada uno de los enfoques para ver más en detalle cada uno de ellos, en primera instancia vamos a iniciar con Data Base First, que como había mencionado nos permite generar automáticamente nuestro modelo y nuestras clases Poco, teniendo como punto de referencia una base de datos previamente creada. Pues veamos cómo podemos lograr esto:

Para nuestro ejemplo vamos a trabajar con la famosa base de datos Northwnd, de la cual comparto un .bk para que puedan seguir paso a paso la demo:

Northwnd DB

Una vez restauremos la base de datos, generamos nuestro EntityDataModel, que generará nuestro modelo conceptual y las clases poco que estarán mapeadas a él, para esto seguimos los siguientes pasos:

1. En nuestro proyecto que puede ser una librería de clases, sitio web, consola, etc. Oprimimos clic derecho y elegimos la opción agregar nuevo elemento, posteriormente filtramos los tipos de elementos por datos y por ultimo elegimos ADO.NET Entity Data Model y hacemos clic sobre el botón agregar, no sin antes darle un nombre a nuestro modelo:







Posteriormente nos muestra dos opciones, la primera para generar desde una base de datos existente y la otra para crear un modelo en blanco, en nuestro caso seleccionamos la primera para crear desde nuestra DB Northwnd:





2. Ahora debemos especificar los datos de conexión a nuestra base de datos, para esto hacemos clic en el botón "Nueva conexión", luego vemos como se genera una cadena de conexión y podemos elegir si mostrarla en el archivo de configuración de nuestro proyecto o no:







Una vez lista nuestra conexión podemos elegir que versión de EntityFramework vamos a usar, para nuestro ejemplo usaremos la versión 6 que es la última versión recientemente liberada:





3. Y para finalizar, debemos elegir los elementos de nuestra base de datos que queremos que sean incluidos en nuestro modelo:

Y nuestro resultado final es el modelo que visualizamos de inmediato, con sus respectivas relaciones, procedimientos almacenados y funciones si es que los seleccionamos para incluir, todo esto representado en un archivo con extensión .edmx, el cual si exploramos bien contiene el diagrama y además todas las clases auto generadas que corresponden a las tablas en nuestras base de datos:

Bueno amigos eso es todo por esta ocasión. Con esto damos inicio a EntityFramework DB First, en próximos artículos profundizaremos más acerca de este modelo que generamos y como interactuar con el para el acceso a datos de nuestras aplicaciones, espero les sea de utilidad.

Buena suerte! y saludos.

[EntityFramework] DB First, Model first o Code first ¿cuál elegir?

EntityFramework nos provee cuatro enfoques o tres formas para crear nuestro modelo conceptual o modelo de dominio, los cuales describo a continuación:

1. DataBase First: Permite obtener un modelo basado en una base de datos existente, todas las clases del modelo serán generadas automáticamente a través de plantillas de generación de código T4, digamos que este flujo es muy común ya que solemos modelar en primera instancia nuestra base de datos y a lo largo del proyecto trabajamos sobre ella, nuestro modelo generado quedará almacenado en un archivo con extensión .edmx y este se podrá ver y editar en un diseñador, para actualizar nuevos cambios que surjan en nuestra base de datos.
2. Model First: En este enfoque creamos en primera instancia nuestro modelo conceptual a través de un Entity Data Model, y posteriormente basados en este modelo creamos nuestra base de datos, una ventaja de este enfoque es que nos concentramos en el dominio de nuestra aplicación y EF se encarga de crear la base de datos con la información que consignamos en el modelo.
3. Code First: Con este enfoque nos salimos un poco de lo normal, en este caso primero codificamos nuestras clases de dominio o clases POCO y luego basados en ellas creamos nuestro modelo y base de datos, solo debemos crearlas y hacer uso de DBContext y DBSet para cada clase que se creara en nuestra base de datos, para manejar las actualizaciones en nuestra DB tenemos DataBase Migrations que nos permite actualizar los cambios sobre nuestras clases.
4. Code First From Data Base: Este enfoque es el más reciente creado por Microsoft, y a decir verdad es mi preferido, ya que combina el manejo y autonomía de Code first con la facilidad para crear el modelo inicial de DataBase first, ya que nos permite crear nuestro contexto y entidades basadas en nuestra base de datos, pero esta vez no tendremos que lidiar con clases auto generadas las cuales debemos extender con clases parciales y clases de metadata, ya que nuestras entidades se generarán una vez y luego las actualizaremos manualmente y replicaremos los cambios en la base de datos a través de migraciones.

Bueno ahora que conocemos los diferentes enfoques que nos permite EntityFramework para crear nuestro modelo conceptual, me imagino que elegir uno u otro radica mucho en nuestros gustos y costumbres como desarrolladores, sin embargo también existe un factor que puede influir y es el insumo con el que contemos en el momento, es decir, si ya contamos con una base de datos creada por ejemplo, o si tenemos un modelo establecido o si simplemente ya tenemos unas clases creadas, lo importante es que sepamos que para cada uno de estos casos EF nos ofrece una solución, con esto podemos ahorrar bastante trabajo según sea nuestro caso. Por ultimo les quiero compartir una gráfica que he encontrado que podría resumir este artículo:

Bueno amigos espero este artículo les sea de utilidad a la hora de elegir un enfoque de EntityFramework, en próximos artículos veremos en detalle cada uno de los enfoques y su implementación.

Actualizado 20/04/2015, se agrega descripción de enfoque Code First From Data Base.

saludos!