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

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

[Tip] Extraer cadenas de una cadena principal con expresiones regulares

En muchas ocasiones necesitamos extraer palabras o caracteres que cumplan con ciertas condiciones de una cadena mayor, hay muchas formas de hacerlo unas más laboriosas o menos genéricas que otras, para este tipo de casos nos son muy útiles las expresiones regulares, como en el siguiente ejemplo, se necesita extraer las palabras encerradas en [corchetes] de una cadena, esto lo podemos lograr de la siguiente forma:

Cadena: [EDAD]:25:NUMERICO;[SUELDO]:1200:NUMERICO;[ESTADOCIVIL]:'C':TEXTO

string pattern = Regex.Escape("[") + "(.*?)]";
string input = "[EDAD]:25:NUMERICO;[SUELDO]:1200:NUMERICO;[ESTADOCIVIL]:'C':TEXTO";

MatchCollection matches = Regex.Matches(input, pattern);
foreach (Match match in matches)
     Response.Write(match.Value);

Observemos que con la instrucción Regex.Escape indicamos que no los caracteres especiales no sean tenidos en cuenta como parte de la expresión regular si no como parte del patrón que deseamos buscar.

El resultado que imprime nuestro algoritmo es:

[EDAD][SUELDO][ESTADOCIVIL]

Espero les sea de utilidad.

Saludos!!

Creando un mini blog con Asp.net y MongoDB

En este artículo vamos a ver como crear un mini blog utilizando asp.net conectándonos a una base de datos no sql como lo es MongoDB, que es una base de datos documental que usa archivos en formato JSON para almacenar información. para mayor detalle acerca de esta base de datos remitirse al su sitio oficial http://www.mongodb.org/

Para una introducción a las bases de datos no sql, recomiendo observar mi presentación anterior:
http://eltavodev.blogspot.com/2013/07/introduccion-las-bases-de-datos-no-sql.html

Lo primero que debemos hacer para realizar nuestro ejemplo es descargar e instalar la base de datos MongoDB, para su instalación se deben seguir las siguientes instrucciones:
http://docs.mongodb.org/manual/installation/

Una vez instalada nuestra base de datos, debemos descargar las dll que ofrece MongoDB para trabajar en la plataforma .NET, estas dll las descargamos en la siguiente url:
http://docs.mongodb.org/ecosystem/tutorial/getting-started-with-csharp-driver/#getting-started-with-csharp-driver

Ahora creamos un proyecto web asp.net en nuestro Visual Studio, y agregamos la referencia de la dll MongoDB.Driver.dll, y en nuestra página agregamos la instrucción:

using MongoDB.Driver;
using MongoDB.Driver.Builders;

Con estas referencias ya podemos interactuar con la base de datos.

Ahora vamos a iniciar a implementar nuestro ejemplo, en el cual podremos guardar un nuevo articulo en nuestro blog y buscarlo posteriormente. Visualmente es de la siguiente forma:

En primera instancia vamos a crear un método para abrir la conexión con nuestra base de datos y especificamos en que colección vamos a guardar o consultar:

private void ConectarDB()
{
      string connectionString = "mongodb://localhost";
      MongoClient client = new MongoClient(connectionString);
      MongoServer server = client.GetServer();
      MongoDatabase database = server.GetDatabase("MiBlog");
      this.collection = database.GetCollection<Articulo>("Articulos");
}

En el fragmento de código anterior especificamos una cadena de conexión básica, con los objetos MongoClient y MongoServer obtenemos acceso al servidor de base de datos, con el objeto MongoDataBase especificamos a que base de datos nos deseamos conectar y con el método GetCollection indicamos que queremos efectuar operaciones sobre la colección Articulos, el termino colección en Mongo se puede homologar como una tabla en una base de datos relacional.

Como en nuestro ejemplo vamos a usar nuestros objetos del dominio para almacenarlos en la base de datos, y no estructuras dinámicas vamos a crear una entidad Articulo para almacenarla en nuestra colección de artículos:

public class Articulo
{
      public ObjectId Id { get; set; }
 
      public string Titulo { get; set; }
 
      public string Contenido { get; set; }
}

Ahora en el evento click de nuestro botón guardar vamos a copiar lo siguiente:

this.ConectarDB();
 
Articulo articulo = new Articulo { Titulo = this.txtTitulo.Text, Contenido = this.txtContenido.Text };
this.collection.Insert(articulo);

En el fragmento de código anterior, en primer lugar nos conectamos a nuestra base de datos, posteriormente creamos un nuevo objeto artículo con los datos digitados por el usuario y por ultimo lo insertamos en la base de datos.

Para finalizar nuestro ejemplo vamos a ver como recuperar un artículo de nuestra base de datos, donde el titulo contenga las palabras digitadas por el usuario en el cuadro de texto de búsqueda, para ello copiamos lo siguiente en el evento click del botón Buscar:

this.ConectarDB();
var query = Query<Articulo>.Matches(c => c.Titulo, this.txtBusqueda.Text);
Articulo articulo = collection.FindOne(query);
 
this.txtTitulo.Text = articulo.Titulo;
this.txtContenido.Text = articulo.Contenido;

Con el fragmento de código anterior, en primer lugar nos conectamos a nuestra base de datos, luego con una expresión lambda especificamos que se busquen los artículos cuyo titulo contenga las palabras digitadas en el cuadro de texto de búsqueda, y posteriormente decimos que nos traiga un solo artículo con la extensión FinOne, y por ultimo mostramos el artículo al usuario.

Con esto damos por terminado nuestro ejemplo de como crear un blog básico con Asp.net y MongoDB, espero los sea de gran utilidad, a continuación el link de descarga del código de ejemplo:

https://www.dropbox.com/s/le3xw5opf7ry8cp/Ejemplo%20MongoDB.rar

Saludos y buena suerte!!!

Introducción a las bases de datos No Sql y sus ventajas

Saludos, les comparto la presentación de mi charla dictada en el BarCamp Medellín 2013.

Introducción a No sql from Tavo Alzate Sandoval

Jquery metro UI, Añadiendo interfaz estilo metro a tus aplicaciones web

En la mayoría de ocasiones cuando desarrollamos un sitio web, queremos que tenga una interfaz gráfica muy amigable y atractiva para el usuario y también nos preocupamos por que dicha interfaz sea liviana y no afecte el desempeño de nuestra aplicación, con la ultima tendencia de interfaz estilo metro vemos que los sitios web son muy atractivos visualmente y que además dicha interfaz es bastante liviana y permite una ágil navegación a través del sitio, por esto considero que es una gran alternativa a la hora de diseñar nuestro sitio web.

En este artículo vamos a ver como incorporar de una forma muy sencilla, interfaz estilo metro a nuestras aplicaciones web, utilizando librerías de Jquery para lograrlo.

comencemos por referenciar las librerías y estilos básicos de Jquery:

<link href="Styles/jquery-ui.css" rel="stylesheet" type="text/css" />

<script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script>

Ahora debemos descargar el tema que nos permitirá que se aplique el estilo metro a todos los widgest de Jquery que tengamos en nuestra página, en la siguiente url podemos generar nuestro tema http://jquit.com/builder, personalizando colores y demás y posteriormente descargar el archivo jquery-ui-1.8.16.custom.min.js que se encargará de aplicar el estilo metro a los widgest y una vez tengamos este archivo lo referenciamos en nuestra página:

<script type="text/javascript" src="Scripts/jquery-ui-1.8.16.custom.min.js"></script>

Con esto logramos que widgest como Accordion, Button, DatePicker, Dialog, Tabs y demás que estemos usando se vean automáticamente con la interfaz metro que queremos, veamos visualmente algunos ejemplos:

Para terminar nuestro ejemplo vamos a ver como crear un menú estilo metro de una manera muy sencilla, en la siguiente url encontramos el API que usaremos: http://jqmetro.codeplex.com/, describe como podemos implementar rápidamente un menú similar o mucho mejor que este:

Solo tenemos que referenciar los siguientes estilos y librería de jquery:

<link href="Styles/jq-metro.css" rel="stylesheet" type="text/css" />

<script type="text/javascript" src="Scripts/jquery.metro-btn.js"></script>

Agregamos un div

<div id="metrobuttons" class="metro-panel">
</div>

Y agregamos botones con la siguiente instrucción:

$("#metrobuttons").AddMetroSimpleButton('bt1', 'metro-verde', 'Styles/Images/Acuerdos.png', 'Acuerdos', '#');

Con esto damos por terminado nuestro artículo de como incorporar interfaz estilo metro a nuestras aplicaciones web, espero les sea de gran utilidad, a continuación el link de descarga delos materiales de ejemplo.

https://www.dropbox.com/s/gqjvg767v8i4ybz/JqueyMetroUI.rar

Y también les comparto una buena herramienta muy útil para diseñar iconos con estilo metro:
http://www.syncfusion.com/downloads/metrostudio

Saludos.

Programación paralela a través de tareas (Task) en .NET

En muchas ocasiones se nos presentan escenarios en los cuales debemos ejecutar procesos de forma paralela, debido a que de forma secuencial se vuelven muy lentos y bloquean al usuario por un tiempo considerable, uno de estos escenarios puede ser si en una aplicación de reservas de vuelos online, debemos buscar disponibilidad mediante web services tanto para la aerolínea A como para la aerolínea B, si lo ejecutamos de forma secuencial iniciamos el llamado a A, y cuando este termine iniciamos el llamado a B, esto tardaría un tiempo considerable, la mejor forma sería ejecutando los llamados al mismo tiempo, usando Multithreading o usando paralelismo, en nuestro ejemplo vamos a usar paralelismo ya que vamos a usar todos los núcleos de nuestro procesador.

Para tener conceptos claros acerca de la programación paralela, recomiendo leer mi artículo anterior "Introducción a la programación paralela"

http://eltavodev.blogspot.com/2013/05/introduccion-la-programacion-paralela.html

Ahora vamos a ver ejemplos de cómo usar paralelismo a través de tareas en .NET, crearemos la siguiente aplicación:

A lo largo del ejemplo vamos a usar tres métodos: TareaA(), TareaB, TareaC(), tarea A, tiene un tiempo de retardo para efectos del ejercicio:

private void TareaA()
{
      Thread.Sleep(2000);
      MessageBox.Show("Se ejecutó la tárea A");
}

En nuestro primer botón "Task", vamos a crear una tarea indicándole que debe ejecutar nuestro método TareaA, e iniciamos la tarea:

Task t = new Task(this.TareaA);
t.Start();

También podemos crear tareas que ejecuten múltiples instrucciones:

Task t = Task.Factory.StartNew(() =>
{
      this.TareaA();
      int resultado = 1 + 2;
});
this.TareaB();

También podemos tipar nuestras tareas:

Task<int> t = Task.Factory.StartNew(() =>
{
      return 1 + 2;
});
MessageBox.Show((t.Result + 1).ToString());

Si queremos especificar una secuencia de ejecución para nuestras tareas, lo podemos hacer mediante la instrucción ContinueWith:

Task.Factory.StartNew(() =>
{
      this.TareaA();
}).ContinueWith((t) => TareaB());

Y por último vamos ver como sincronizar el fin de ejecución de todas nuestras tareas, muy útil en caso de que necesitemos ejecutar algún proceso cuando terminen todas las tareas que tenemos ejecutándose en paralelo:

Task t = new Task(this.TareaA);
t.Start();
 
Task t2 = new Task(this.TareaB);
t2.Start();
 
Task t3 = new Task(this.TareaC);
t3.Start();
 
Task.WaitAll(new Task[] { t, t2, t3 });
 
MessageBox.Show("Se terminó la ejecución de todas las táreas");

Con esto damos por terminado nuestro artículo sobre programación paralela a través de tareas, espero les sea de gran utilidad, a continuación el link de descarga del código de ejemplo:

https://www.dropbox.com/s/gsjhi12w68r1wuq/EjemploPTask.rar

Saludos.

Lo que se viene con Microsoft Visual Studio 2013!!!

Les comparto un adelanto acerca de las nuevas características que incorporará el nuevo Visual Studio 2013.

http://blogs.msdn.com/b/esmsdn/archive/2013/06/05/presentando-visual-studio-2013-y-dem-225-s-novedades.aspx

Saludos.

Consultas Linq to Objects en paralelo con Plinq

En este artículo vamos a ver como optimizar nuestras consultas linq to objects usando todos los núcleos de nuestro procesador a través de Plinq.

Para tener conceptos claros acerca de la programación paralela, recomiendo leer mi artículo anterior “Introducción a la programación paralela”

http://eltavodev.blogspot.com/2013/05/introduccion-la-programacion-paralela.html

¿Qué es Plinq?

Parallel LINQ (PLINQ) es una implementación paralela de LINQ to Objects. PLINQ implementa el conjunto completo de operadores de consulta estándar de LINQ como métodos de extensión para el espacio de nombres T:System.Linq y tiene operadores adicionales para las operaciones paralelas.

Para entrar en materia vamos a ver ejemplos de consultas linq to objects y consultas Plinq y vamos a comparar el tiempo que tarda cada una, para eso implementaremos el siguiente formulario:

Para nuestras consultas vamos a declarar una enumeración de 1 a 10’000.000, un Stopwatch para medir el tiempo que tardan las consultas y vamos a crear un método que busque los números primos en el rango anterior con el fin de darle complejidad a las consultas para que tarden más tiempo para efectos de nuestro ejemplo.

        private bool esPRimo(int n)
        {
            if (n <= 1) return false;
            if ((n & 1) == 0)
            {
                if (n == 2) return true;
                else return false;
            }
            for (int i = 3; (i * i) <= n; i += 2)
            {
                if ((n % i) == 0) return false;
            }
            return n != 1;
        }

        IEnumerable<int> numeros = Enumerable.Range(1, 10000000);
        Stopwatch tiempo = new Stopwatch();

En el evento click de nuestro primer botón “Linq” vamos a copiar el siguiente fragmento de código para realizar la consulta a través de linq to objects y mostrar el tiempo transcurrido:

            tiempo.Restart();
            var con = numeros.Where(c => esPRimo(c));
            con.ToList();
            tiempo.Stop();
            this.lblTiempo.Text = string.Format("Tiempo transcurrido: {0}",  tiempo.ElapsedMilliseconds.ToString("n2"));

Esta consulta tarda 5.715 milisegundos, una diferencia considerable con la siguiente implementación en paralelo que tarda 2.909 milisegundos

            tiempo.Restart();
            var con = numeros.AsParallel().Where(c => esPRimo(c));
            con.ToList();
            tiempo.Stop();
            this.lblTiempo.Text = string.Format("Tiempo transcurrido: {0}", tiempo.ElapsedMilliseconds.ToString("n2"));

Nótese que solo tuvimos que usar la extensión AsParallel para usar los demás cores del procesador, observemos el comportamiento de nuestro procesador con el administrador de tareas:

Imagen de consulta linq to objects:

Imagen de consulta Plinq:

Podemos observar como en la consulta de linq to objects se dispara el uso de un solo núcleo del procesador, mientras que en la consulta Plinq se dispara el uso de todos los núcleos, he ahí la gran diferencia en tiempo.

Algo a tener en cuenta es que nuestra consulta Plinq no devolverá los resultados en orden, ya que no procesa de forma secuencial, en caso de que necesitemos obtener en orden los números como es el caso de nuestro ejemplo solo basta con hacer uso de la extensión AsOrdered, como se muestra a continuación:

var con = numeros.AsParallel().AsOrdered().Where(c => esPRimo(c));

Obviamente eso hace que tarde un poco más nuestra consulta pero no es mucho, solo aproximadamente un milisegundo.

Para terminar nuestro ejemplo hay un aspecto que es importante resaltar y es la especificación del grado de paralelismo que deseamos utilizar en nuestras consultas y lo logramos con la extensión WithDegreeOfParallelism(Environment.ProcessorCount / 2) y especificamos el número de núcleos que queremos usar.

            tiempo.Restart();
            var con = numeros.AsParallel().WithDegreeOfParallelism(Environment.ProcessorCount / 2).Where(c => esPRimo(c));
            con.ToList();
            tiempo.Stop();
            this.lblTiempo.Text = string.Format("Tiempo transcurrido: {0}", tiempo.ElapsedMilliseconds.ToString("n2"));

En el ejemplo anterior usamos la mitad de los núcleos que tiene el procesador.

Con esto damos por terminado nuestro artículo sobre Plinq, espero les sea de gran utilidad, en un próximo artículo veremos otra forma de paralelismo en .NET como lo es el paralelismo mediante Tareas.

A continuación el link de descarga del ejemplo.

https://www.dropbox.com/s/ogk7skbwfmt5qcf/EjemploPlinq.rar

Saludos.

Introducción a la programación paralela

En este artículo vamos a dar un vistazo acerca de la programación paralela, para que nos sirve, conceptos importantes y que nos ofrece Microsoft .NET para implementarla, veamos:

¿Para qué nos sirve?  

• La programación paralela nos sirve para ejecutar varias tareas de forma simultanea.
• Se rige bajo el principio de que problemas grandes se pueden dividir en unos más pequeños, para ser resueltos simultáneamente.
• Existen los siguientes tipos de paralelismo: a nivel de bit, instrucción, datos y tareas.     

El concepto de paralelismo toma fuerza, debido a que los procesadores en la actualidad buscan tener más núcleos para desempeñarse mejor, y no tener más velocidad con un solo núcleo debido a temas de recalentamiento.

Conceptos importantes:

• Proceso: Proporciona los recursos necesarios para ejecutar un programa, se inicia con un código único de identificación y ocupa un espacio en memoria virtual, requiere al menos un hilo para ejecutarse. 
• Hilos (Threads): Entidad dentro de un proceso que realmente ejecuta código. Todos los hilos comparten los recursos y memoria virtual del proceso donde se ejecutan.

Consideraciones:

• A mayor cantidad de hilos, mayor uso de CPU, ya que el sistema operativo sede el recurso basado en el número de hilos. 
• Las aplicaciones .NET usan al menos dos hilos para ejecutarse, uno para ejecutar su código y otro para el Collector. 
• Cuando un proceso tiene muchos hilos consume mucho más tiempo de CPU que los demás y funciona bastante rápido, pero los demás procesos deben esperar más.

Diferenciemos dos conceptos que suelen confundirse como lo son Multithreading y paralelismo.

Multithreading v.s paralelismo

• Multithreading Permite manejar varios hilos en una aplicación. 
• Permite realizar tareas asíncronas, pero usa un solo core del procesador. 
• Es complejo para controlar, difícil de depurar y no permite acceso a UI.

• Paralelismo Permite implementar multithreading usando varios core del procesador. 
• Permite un fácil manejo y buena depuración. 
• Permite acceso a UI. 
• Permite especificar cuantos core del procesador usar para un tarea en especifico.

¿Qué nos ofrece .NET Framework para trabajar paralelismo?

• PLinq: Consultas Linq to Objects con paralelismo.
• Data Parallel: Paralelismo con bucles.
• Task: Agrupa instrucciones para ser ejecutas en paralelo.
• Concurrent: Maneja sincronización en colecciones.
• Depuración: Permite depurar diferentes hilos ejecutándose en paralelo. 

Esto es una breve introducción a la programación paralela, en próximos artículos veremos como implementar paralelismo en .NET, espero les sea de utilidad.

CRUD BÁSICO CON WCF DATA SERVICES, AJAX Y JQUERY.

En este artículo vamos a ver cómo implementar un CRUD básico a través de WCF Data Services, pero en esta ocasión lo vamos a hacer totalmente desde el lado del cliente, usando AJAX para invocar nuestros servicios de datos usando los verbos básicos de http GET, POST, PUT y DELETE, y usando el plugin jqxGrid de Jquery  en una versión no comercial, para mostrar los datos en una grilla, para esto vamos a seguir los siguientes pasos:

1.       Crear aplicación Asp.net

2.       Crear modelo de datos con Entity Framework

3.       Crear WCF Data Service

4.       Configurar WCF Data Service para acceso a nuestras entidades.

5.       Referenciar librerías para usar el jqxGrid.

6.       Crear llamados AJAX para interactuar con WCF Data Services.

Para los primeros cuatro pasos remitirse a mi anterior artículo:

http://eltavodev.blogspot.com/2013/04/crud-basico-con-wcf-data-services.html

5. Referenciar librerías para usar el jqxGrid.

Para usar el plugin jqxGrid, debemos referenciar las siguientes librerías y estilos:

<link rel="stylesheet" href="http://www.jqwidgets.com/jquery-widgets-demo/jqwidgets/styles/jqx.base.css"

        type="text/css" />

    <script src="http://www.jqwidgets.com/jquery-widgets-demo/scripts/jquery-1.8.2.min.js"

        type="text/javascript"></script>

    <script src="http://www.jqwidgets.com/jquery-widgets-demo/jqwidgets/jqx-all.js" type="text/javascript"></script>

6.   Crear llamados AJAX para interactuar con WCF Data Services.

En nuestro ejemplo vamos a crear un CRUD básico para la tabla Customers, visualmente es de la siguiente forma:

Para cargar nuestro grid, vamos a incluir los siguientes scripts en el encabezado del HTML:

$(document).ready(function () {

ConsultarClientes();

       $("#gridClientes").bind('rowselect', function (event) {

             $("#txtID").val(event.args.row.CustomerID);

             $("#txtNombre").val(event.args.row.ContactName);

             $("#txtCompania").val(event.args.row.CompanyName);

             $("#hfAccion").val("Modificar");

       });

       $('#gridClientes').on('rowdoubleclick', function (event) {

if (confirm("Está seguro de eliminar el cliente: " + event.args.owner.rows.records[event.args.rowindex].bounddata.ContactName))

{

EliminarCliente(event.args.owner.rows.records[event.args.rowindex].bounddata.CustomerID);

              }

       });

});

// Cargar grid con los clientes existentes

function ConsultarClientes() {

var source = {

       type: "GET",

       datatype: "json",

       datafields: [

                    { name: 'CustomerID' },

                    { name: 'ContactName' },

                    { name: 'CompanyName' }

                ],

       url: 'NorttwindAccess.svc/Customers',

       cache: false,

       root: 'data'

       };

var dataAdapter = new $.jqx.dataAdapter(source, { contentType: 'application/json; charset=utf-8',

        downloadComplete: function (data, textStatus, jqXHR) {

                                         return data.d;

                           }

            }

        );

       $("#gridClientes").jqxGrid({

                source: dataAdapter,

                columns: [

                    { text: 'ID', dataField: 'CustomerID', width: 200 },

                    { text: 'Nombre', dataField: 'ContactName', width: 200 },

                    { text: 'Compañia', dataField: 'CompanyName', width: 180 }

                ]

            });

 }

Con el código anterior cuando carga la página invocamos la función ConsultarClientes(), la cual permite invocar el servicio de datos con la url 'NorttwindAccess.svc/Customers, y luego lo carga en el grid, además de esto adjuntamos dos eventos al grid, rowselect que usamos para cargar el cliente seleccionado en los campos de texto, y el evento rowdobleclick en el cual vamos a realizar la eliminación del cliente cuando se haga doble click sobre él.

 Ahora para eliminar un cliente, agregamos la siguiente función:

// Eliminar un cliente

        function EliminarCliente(id) {

            $.ajax({

                type: "DELETE",

                url: "NorttwindAccess.svc/Customers('" + id + "')",

                data: "{}",

                contentType: "application/json; charset=utf-8",

                dataType: "json",

                success: function (data) {

                    alert("El cliente se eliminó correctamente.");

                },

                error: function (msg) {

                    alert(msg.responseText);

                }

            });

        }

Y para terminar agregamos la siguiente función para guardar y modificar un cliente:

// guardar o modificar un cliente.

        function GuardarCliente() {

            var cliente = {

                CustomerID: $("#txtID").val(),

                ContactName: $("#txtNombre").val(),

                CompanyName: $("#txtCompania").val()

            };

            var verbo = "POST";

            var mensaje = "Cliente ingresado correctamente.";

            var URL = "NorttwindAccess.svc/Customers";

            if ($("#hfAccion").val("Modificar")) {

                verbo = "PUT";

                mensaje = "Cliente modificado correctamente.";

                URL = "NorttwindAccess.svc/Customers('"+ $("#txtID").val() +"')";

            }

            $.ajax({

                type: verbo,

                url: URL,

                data: JSON.stringify(cliente),

                contentType: "application/json; charset=utf-8",

                dataType: "json",

                success: function (data) {

                    $("#hfAccion").val("Nuevo");

                    LimpiarCajas();

                    alert(mensaje);

                },

                error: function (msg) {

                    alert(msg.responseText);

                }

            });

        }

Con esto damos por terminado nuestro ejemplo de cómo implementar un CRUD básico usando WCF Data Services mediante llamados AJAX, es una forma sencilla de realizar una implementación sin usar código del lado del servidor, espero les sea de gran utilidad, a continuación el link de descarga del código fuente, para mayor detalle, la implementación está en el archivo PruebaClientes.aspx.

https://www.dropbox.com/s/v3wcbg7kh65ktrn/WCFDataServicesExample%20-%20copia.rar

Saludos.