lunes, 14 de abril de 2014

Realizar Consultas con LINQ (parte 2)

Continuando con esta entrega sobre las posibilidades que nos ofrece LINQ para realizar consultas, comenzaremos viendo de que manera simple pueden realizarse agrupamiento de datos.

(Ir a primer parte click aqui)

Tomando como base la clase empleado que utilizamos en la primer parte de esta entrega, podemos ver a continuación de que manera LINQ simplifica enormemente el proceso de agrupar datos, utilizando una sintaxis similar al GROUP BY de SQL.




Por otro lado, LINQ hace posible que se pueden ejecutar sobre cualquier objeto enumerable, muchos operados similares a los operadores que se encuentran en SQL, tales como Count, Min, Max, Avarage, Sum.




Como se ve en el ejemplo se simplifica ampliamente la posibilidad de obtener estos valores, a excepción del Count, que nos devuelve la cantidad total, el resto de los operadores requieren el nombre del campo sobre el cual se efectúa la operación, ello se realiza por medio del uso de la expresión Lambda.

LINQ suporta la unión de datos desde diferentes colecciones, usando una sintaxis similar a la utilizada por SQL, para ejemplificar esto, creamos una clase GrupoEmpleado, 

para relacionarla con el atributo IdGrupoEmpleado de la Clase Empleado






LINQ también nos otorga la posibilidad de realizar paginado de datos fácilmente, por medio de la utilización de los métodos Skip y Take. El primero de ellos, Skip, determina la

posición del primer item de la lista a considerar,  y por medio del método Take, se especifica la cantidad de items que serán retornados en la consulta LINQ.


Como puede observarse LINQ nos otorga una espectacular mejora en la legibilidad y comprensibilidad del código.

viernes, 11 de abril de 2014

Realizar Consultas con LINQ (parte 1)

Como ya había sido introducido previamente el tema, LINQ (Language Integrated Query), incluye tres tipos básicos de consultas, estos son:

  1. LINQ to Objects; 
  2. LINQ to XLM (XLINQ); 
  3. LINQ utilizados en contextos de bases de datos, tales como LINQ to SQL o LINQ to Entities.

Para analizar más en profundidad algunas de las posibilidades que nos ofrece LINQ, tomaremos el enfoque más simple, LINQ to Objects, este enfoque permite realizar operaciones de consultas complejas en cualquier objeto que soporte la interface IEnumerable.

Para analizar estas cuestiones, comenzaremos definiendo una clase simple: Empleado


Y posteriormente llenaremos una Lista de clase Empleado, la cual contendrá las instancias de la entidad Empleado.



Cargamos el contenido de la Lista de Empleados en una variable genérica, y posteriormente lo que se haría, sería enviar la variable a la vista correspondiente, para que el usuario vea los resultados finales (si estuviéramos en una aplicación MVC), o se podría asignar dicha variable al DataSource de una GridView (si estuavieramos trabajando con Web Forms). Para simplemente probar su funcionamiento, lo que haremos será recorrer el contenido de la variable por medio de un bucle foreach.



¿Qué pasaría si desearamos ordenar, agrupar, paginar, dicha lista? Obviamente por medio de unas cuantas líneas de código podríamos hacerlo, pero el código, algunas veces, puede resultar difícil de leer y entender para alguien que no fue el programador, por lo cual se entorpece el mantenimiento del sistema. Es aquí donde entra en juego LINQ.

Por este motivo, partir de ahora, iremos testeando las diversas posibilidades que nos ofrece LINQ, lo primero es generar la consulta LINQ simple de la siguiente manera, como se ve obtenemos un resultado similar al anterior, pero nos servirá como base para los pasos siguientes.


Analicemos en detalle, este ejemplo de LINQ Básico: primero por medio del método ObtenerEmpleados(), se obtiene la variable genérica de List<Empleado>; y posteriormente se realiza una consulta LINQ muy simple para obtener todos los objetos Empleado de la colección de Empleados.

Como puede verse la consulta definió una nueva variable e, esta variable es utilizada de dos maneras dentro de la consulta. Por un lado, definiendo dicha variable e dentro de la sentencia from, le estamos diciendo a LINQ que e representa un item individual dentro de la colección, para el ejemplo e es un objeto Empleado. Por otro lado, utilizando e, dentro de la sentencia select de la consulta, le estamos diciendo a LINQ que genere una salida que se corresponde con la estructura de e, en este ejemplo con la estructura del objeto Empleado.
Con respecto a este último punto, podemos generar una salida personalizada, es decir determinar que campos se quiere que retorne la consulta, para ello utilizamos la palabra reservada new, posterior a la sentencia select, como podemos ver en el siguiente ejemplo:



También podemos determinar cuales serán los nombres de los campos que expondrá la salida de nuestra consulta LINQ


LINQ incluye la capacidad de ordenar los resultados de nuestra consulta, utilizando la sentencia ORDER BY, y tal colo lo haríamos en una consulta SQL, puede determinarse si los datos se ordenan de manera ascendente o descendente.



Si deseamos filtrar los datos de nuestra consulta LINQ, solo es cuestion de agregar la sentencia WHERE, tal como vemos a continuación:


Si deseamos hacer un filtrado más preciso fácilmente pueden introducirse más condiciones dentro del WHERE de la consulta:


En la próxima entrega veremos cuestiones tales como el Agrupamiento de datos, funciones de agregado, paginado de resultados.

(Ir a segunda parte click aquí)

lunes, 31 de marzo de 2014

Entity Framework Code First

Code First, de Entity Framework, es el último enfoque agregado al Entity Framework, e introducido en la versión 4.1 del Framework de .NET (Los dos enfoques previos son Database First y Model First). 

Este enfoque, como su nombre lo dice, se basa en codificar primero, es decir crear clases POCO (Plain Old CLR Objects), utilizando el lenguaje deseado, VB.NET, C#, etc. de las diferentes entidades, y crear relaciones entre las mismas, luego se crea automáticamente la base de datos. Esta es la principal utilidad del EF Code First, aunque también puede utilizarse con Bases de Datos existentes, lo cual nos da un mayor control sobre el código generado, ya que nada será realizado por el asistente. 

La ventaja principal que posee el enfoque "Code First", es que ya no debemos preocuparnos mas por Transact SQL, ni por la base de datos en sí, ya que la misma será la manera en que se persisten los objetos creados. En síntesis, estaremos programando solamente con C# o VB.NET y LINQ.



Para abordar este enfoque, se debe comenzar definiendo nuestras entidades, lo cual puede realizarse como objetos POCO.




Luego de la definición de todas las entidades necesarias, se debe proceder a crear la clase de contexto para interactuar con la base de datos.





Tratándose de una aplicación web, en nuestro archivo web.config debe determinarse la cadena conexión a la base de datos, dentro de la correspondiente sección <connectionStrings>.




Posteriormente a esta configuración inicial de nuestro modelo, y sin necesidad de crear siquiera nuestra base de datos en el servidor definido en el web.config, podemos utilizar el modelo, para crear un nuevo empleado, y al llamar al método SaveChanges() de nuestro contexto se procederá a crear la base de datos, la tabla correspondiente en la base de datos y se insertará un registro en la misma. 



Posteriormente podemos conectarnos al servidor de nuestra base de datos, y verificar que todo ocurrió tal como fue codificado con nuestro EF Code First.

Más adelante entraremos más en detalle en la definición de las clases POCO, para lograr que se realicen las validaciones correspondientes al momento de registrar datos en las entidades y por consecuencia en la base de datos.