[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.

[WebCast] Avanet - Web móvil, Introducción a No Sql, KnocKoutJS, EmberJS, Google DART

Hola amigos, les comparto el evento virtual de nuestra comunidad Avanet realizado el día de hoy 30/11/2013, donde se tocan bastantes temas interesantes como Web Móvil con BootStrap, knockoutjs, MVC 5, Ember.js, No sql y demás, en esta oportunidad estuve compartiendo una introducción a las bases de datos No Sql y como usar MongoDB con C#, espero les sea de utilidad:

[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!

[Tip] Obtener todos los controles de un formulario de un tipo en especifico

En muchas ocasiones requerimos buscar todos los controles de un tipo en especifico que tenemos en nuestros formularios, por ejemplo si tenemos muchos TextBox y queremos comparar sus valores sin tener que hacerlo uno a uno, o si por ejemplo agregamos dinamicamente N controles a nuestro formulario o algún contenedor, para lograr esto muchas veces recurrimos a un ciclo que recorra cada control de nuestro formulario y pregunte por su tipo para realizar una acción o no, pues bueno voy a mostrar una forma mucho más sencilla de hacerlo.

En nuestro ejemplo vamos tener N TextBox contenidos en un panel, y el objetivo es validar si algún TextBox tiene un Text repetido con otro:

Primero obtenemos todos los controles de tipo TextBox contenidos en nuestro panel, de la siguiente forma:

var controles = this.pnlControles.Controls.OfType<TextBox>();

Ahora ya tenemos una colección con todos los TextBox que necesitamos, ya podemos realizar las consultas Linq o Lambda que requiramos, en nuestro caso usaremos la siguiente:

if (controles.Count(c => c.Text != string.Empty && c.Text.Equals(c.Text)) >= 2)
                MessageBox.Show("Repetido con otro TextBox");

A través de la Lambda Expression preguntamos si existe un algún TextBox con Text repetido, con esto podemos realizar cualquier tipo de validación que necesitemos.

Eso es todo, espero les sea de utilidad.

Saludos!!

[Tip] Realizar consultas a través de Lambda Expressions en un DataSet con tablas relacionadas

En muchas de nuestras aplicaciones necesitamos persistir datos en memoria para usarlos a lo largo de la interacción del usuario en muchos ámbitos del sistema, en muchas de estas ocasiones optamos por el uso de los famosos DataSet, en los cuales almacenamos N DataTable, y cuando necesitamos creamos relaciones entre estos para optimizar y realizar consultas sobre ellos con mayor facilidad. por eso vamos a observar como podemos realizar consultas sobre DataTable relacionados a través de Lambda Expressions, y para eso crearemos un DataSet con la siguiente estructura:

            DataTable categorias = new DataTable();

            categorias.Columns.Add("id", typeof(int));

            DataTable productos = new DataTable();

            productos.Columns.Add("id", typeof(int));

            productos.Columns.Add("name", typeof(string));

            for (int i = 1; i < 4; i++)

            {

                categorias.Rows.Add(i);

            }

            Random rd = new Random(DateTime.Now.Millisecond);

            for (int i = 1; i < 11; i++)

            {

                productos.Rows.Add(rd.Next(1, 4), "Name" + i);

            }

            DataSet ds = new DataSet();

            ds.Tables.Add(categorias);

            ds.Tables.Add(productos);

            ds.Relations.Add(categorias.Columns[0], productos.Columns[0]);

Ahora veamos como realizar una consulta filtrando por el campo name:

var likejoin = category.Rows.OfType<DataRow>().Join(product.Rows.OfType<DataRow>(), cat => cat.Field<int>("id"),

prod => prod.Field<int>("id"), (cat, prod) => new { Id = cat.Field<int>("id"),

Nombre = prod.Field<string>("name") }).Where(c => c.Nombre.Contains("ElTavo"));

Observemos que a través de la extensión Join relacionamos las tablas que necesitemos, y debemos especificar la tabla de relación seguido de los campos de llave primaria que relacionaran las tablas, posteriormente especificamos que campos de las tablas vamos a mostrar en el resultado y por ultimo aplicamos la sentencia WHERE en este caso para filtrar los productos cuyo nombre contenga la palabra ElTavo.

Eso es todo, espero les sea de utilidad.

Saludos!!

[Patrones] - Acceso a datos para soluciones escalables usando sql, No sql y persistencia políglota

Hola amigos, les comparto esta interesante guía publicada por Microsoft para el desarrollo de acceso a datos para soluciones altamente escalables, da a conocer ventajas de las bases de datos No Sql y como se pueden hacer soluciones combinando Sql y No SQL, usando buenas prácticas.

http://msdn.microsoft.com/en-us/library/dn271399.aspx

espero les sea de utilidad.

Saludos!!