LENGUAJES VISUALES II

Docente: Ing. Milciades González Dominguez

LINQ (Manipulando datos en C#)

¿Que es LINQ?
Dejándonos ir por la documentación oficial de Microsoft, LINQ es el nombre de
la tecnología que le da la habilidad al lenguaje de C# de manipular datos (Hacer
queries).

¿Para qué nos sirve aprender LINQ?

Con LINQ tenemos una forma de hacer consultas (queries) sobre diferentes
fuentes de datos (SQL, PostgreSQL, MongoDB y otros) utilizando un solo
lenguaje de programación.

Con LINQ la barrera de entrada para desarrolladores nuevos que comiencen en

nuestro proyecto es más baja ya que utilizamos sintaxis similar a la que ya
utilizan cuando escriben en C# o Java.

Utilizando LINQ
Ahora vamos a comenzar a ver explicaciones con código.

Para comenzar fui a visual studio y seleccioné el template de Console App en

.NET CORE si no tienes Visual Studio puedes utilizar Visual Studio Code con las
herramientas de .NET y crear un proyecto desde el CLI.
Cuando tengamos el proyecto creado vamos a ver una clase que nos generaron
por defecto, la clase llamada Program.cs

Por ahora estaré utilizando la clase Program para enseñarles todos los ejemplos
que estaremos viendo.

IEnumerable y IQueryable
Cuando utilizamos LINQ debemos pensar en las estructuras de datos que
estaremos manipulando. Toda colección (agrupación de datos) que herede de la
interface IEnumerable o IQueryable en C# puede ser manipulada con LINQ.

¿Qué quiero decir con esto?

Vamos a declarar una variable tipo int y otra variable de tipo string.

class Program
{
static void Main(string[] args)
{
string stringVariable;
int intVariable;
}
}
Luego de declarar las variables podremos hacer click + ctrl en la palabra string y
esto nos llevara a la clase de String en el “namespace” de “System”. Si
observamos esta clase podremos ver que hereda de la interface de IEnumerable,
a eso los quería llevar, siempre y cuando estén utilizando una estructura que
herede de IEnumerable o de IQueryable podremos utilizar LINQ sin embargo si
intentamos utilizarlo en la variable de tipo int la cual no hereda de esa
interface veremos que no tenemos los métodos de LINQ disponibles.

String

Int

Consultando datos
Habiendo visto eso, vamos a borrar esas dos variables que declaramos y vamos
a importar en la parte de arriba de nuestro Program.cs dos “namespaces”

using System.Collections.Generic;
using System.Linq;
Ahora en el método de main vamos a declarar una lista con nombres, vamos a
utilizar esta lista para filtrar por nombres específicos utilizando LINQ.

static void Main(string[] args)

{
var customerList = new List<string>
{
"Cliente 1",
"Cliente 2",
"Cliente 3"
};
}
Ahora que tenemos nuestra colección podremos filtrarla utilizando la
palabra where, ósea el nombre de la lista.Where()

class Program
{
static void Main(string[] args)
{
var customerList = new List<string>
{
"Cliente 1",
"Cliente 2",
"Cliente 3"
};
var firstCustomer = customerList.Where(x => x ==
"Cliente 1").SingleOrDefault();
}
}
Como podemos ver en la línea de var firstCustomer =
customerList.Where(x => x == "Cliente
1").SingleOrDefault(); Estamos utilizando la palabra Where la cual utiliza
sintaxis de lambda para buscar en la lista por el nombre de Cliente 1 y a lo
último de la línea de código utilizamos el SingleOrDefault() para ejecutar
nuestra consulta. Esto nos traerá un el primer resultado que encuentre o nulo si
no encuentra nada.

Ahora si ejecutamos nuestro programa y ponemos un breakpoint luego de la

ejecución de nuestra última línea de código podremos ver el valor que nos trae
nuestra consulta.

Y si le ponemos un valor arbitrario que no existe en la lista nos devolverá nulo.

Syntaxis
En el ejemplo que observamos arriba pudimos ver que la sintaxis que se utilizo
para hacer nuestra consulta es bien parecida al código que ya escribimos en C#,
LINQ tiene dos formas de ser escrito method syntax y query syntax. La sintaxis
que utilice el desarrollador va a depender de su preferencia.

La diferencia entre una y la otra es que el method syntax es idéntico al código

de C# y el query syntax es parecido a lo que escribiría en algo como SQL.

Veamos ejemplos de cada sintaxis.

Primero vamos a crear una clase en otro archivo llamada Person, la clase de
person tendrá tres propiedades. El nombre de la persona, un identificador único
y la edad.

public class Person

{
public Guid Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
Ahora volvemos a nuestro Program.cs y vamos a crear una lista de personas con
valores predefinidos.

var peopleList = new List<Person>

{
new Person
{
Id = Guid.NewGuid(),
Name = "Genesis",
Age = 24
},
new Person
{
Id = Guid.NewGuid(),
Name = "Luis",
Age = 23
}
};
Ahora vamos a ver las diferencias entre las sintaxis haciendo una consulta
contra esa lista de personas.

Query Syntax
En la consulta que estoy haciendo en el ejemplo de Query Syntax podemos ver
que la sintaxis es muy parecida a la de SQL, estamos buscando en la lista de
persona por la persona con la edad de 24 años y seleccionando solamente su
nombre.

var ageOfGenesis = (from person in peopleList

where person.Age == 24
select person.Name
).SingleOrDefault();
Method Syntax
var ageOfLuis = peopleList.Where(x => x.Name == "Luis").Select(x
=> x.Name).SingleOrDefault();
En este caso ambos nos devuelven un String siempre y cuando exista en la
colección con el nombre de la persona.
Con LINQ tenemos la habilidad de usar “reflection” una parte muy poderosa del
lenguaje de programación C#. Con esto podemos darle forma a nuestros
resultados de las consultas.

var genesis = (from person in peopleList

select new Person
{
Age = person.Age,
Name = person.Name,
}).FirstOrDefault();

var luis = peopleList.Select(x =>

new Person
{
Age = x.Age,
Name = x.Name
}).LastOrDefault();
Como podemos observar en ambas consultas estamos utilizando la palabra new
Person lo cual nos va a crear un objeto de tipo Person con los valores que le
asignemos, en este caso los valores serán los del resultado de la consulta,
solamente le estoy asignando valores a dos propiedades del objeto Person, la
propiedad de Age y la propiedad de Name .

Filtrando datos
Como pudimos observar en las consultas anteriores, podemos filtrar utilizando
la palabra Where.

var filteredPeopleList = peopleList.Where(x => x.Age > 23 &&

x.Name != "Luis").ToList();
Podemos utilizar diferentes condiciones las cuales pueden ser o ciertas o falsas
para filtrar resultados. Podemos utilizar operadores como > mayor que, < menor
que, == es igual, != no es igual...etc.

Agrupación
Podemos agrupar datos por campos que tengan en común. Por ejemplo en la
consulta a continuación podemos observar que estamos agrupando los datos
por edad, todas las personas que tengan la misma edad va a ser agrupadas en
los resultados y devueltos en una lista de personas.

var groupedPeopleList = (from person in peopleList

 group person
by person.Age
into grouped
select new Person
{
Age = grouped.Key,
Name = String.Join(",",
grouped.Select(x => x.Name))
}).ToList();

En la agrupación cuando estamos utilizando reflection para hacer nuestros

resultados una lista de personas, podemos ver que la edad
dice grouped.Key esto va a asignarle el valor de la propiedad por la cual
estamos agrupando a Age y en la propiedad de Name ya que no estamos
agrupando por nombre vamos a enseñar en una lista separada por comas todos
los nombres que pertenezcan a la agrupación de edades.

Orden
Ordenar datos es sencillo, podemos ver que al
utilizar OrderBy u OrderByDescending podemos ordenar los datos de manera
ascendente o descendiente por el campo que queramos.

var orderedPeopleByAgeAsclist = peopleList.OrderBy(x =>

x.Age).ToList();

var orderedPeopleByNameDesclist = peopleList.OrderByDescending(x

=> x.Name).ToList();
Ahora veamos algunas de las operaciones que podemos llevar a
cabo con LINQ sobre esta:

Select

Nos va a permitir hacer una selección sobre la colección de datos, ya

sea seleccionándolos todos, solo una parte o transformándolos:

var nombresAlumnos = alumnos .Select( x =>

x . Nombre ).ToList();

Where

Nos permite seleccionar una colección a partir de otra con los objetos
que cumplan las condiciones especificadas:

var alumnosAprobados = alumnos .Where( x => x . Nota >=

5).ToList();

First/Last

Esta extensión nos va a permitir obtener respectivamente el primer y

el último objeto de la colección. Esto es especialmente útil si la
colección está ordenada.

var primero = alumnos .First();

var ultimo = alumnos .Last();

OrderBy

Gracias a este método, vamos a poder ordenar la colección en base a

un criterio de ordenación que le indicamos mediante una expresión
lambda. Análogamente, también existe OrderByDescending, el cual
va a ordenar la colección de manera inversa según el criterio:

var ordenadoMenorAMayor = alumnos.OrderBy(x =>

x.Nota).ToList();

var ordenadoMayorAMenos = alumnos.OrderByDescending(x =>

x.Nota).ToList();

Sum

Como hemos visto más arriba, nos va a permitir sumar la colección:

var sumaNotas = alumnos.Sum(x => x.Nota);

Max/Min

Gracias a esta extensión, vamos a poder obtener los valores máximo y

mínimo de la colección:

var notaMaxima = alumnos.Max(x => x.Nota);

var notaMinima = alumnos.Min(x => x.Nota);

Average

Este método nos va a devolver la media aritmética de los valores

(numéricos) de los elementos que le indiquemos de la colección:

var media = alumnos.Average(x => x.Nota);

All/Any

Con este último operador, vamos a poder comprobar si todos o alguno

de los valores de la colección cumplen el criterio que le indiquemos:

var todosAprobados = alumnos.All(x => x.Nota >= 5);

var algunAprobado = alumnos.Any(x => x.Nota >= 5);

Sintaxis integrada

Aunque en los ejemplos anteriores hemos visto el uso directo de los

métodos de extensión, otra de las grandes ventajas que tiene LINQ es
que permite crear expresiones directamente en el código, de manera
similar a si escribiésemos SQL directamente en C#. Por ejemplo:

var resultado = from alumno in alumnos

where alumno . Nota >= 5
orderby alumno .Nota
select alumno ;

nos devolverá la lista de alumnos que tienen una nota superior a o igual
a 5, ordenados por nota ascendentemente.

¿No es algo casi mágico?

Ventajas y desventajas

Ahora que hemos visto un poco por dónde pisamos, es hora de que
hablemos sobre las ventajas y desventajas que nos puede aportar
utilizar LINQ en vez de iterar las colecciones.

La principal y única desventaja que tiene, es que es un poco más lenta

que si utilizásemos bucles for o foreach para iterar la colección y
hacer la operación. Por supuesto esto no es apreciable en
prácticamente ninguna situación convencional, pero en entornos
donde cada milisegundo cuenta, debes conocer que tiene un impacto.

Por otro lado, las ventajas que nos aporta LINQ son principalmente
que el código es más legible, ya que utiliza una sintaxis muy declarativa
de lo que está haciendo, y sobre todo, nos ofrece una manera unificada
de acceder a datos, sean el tipo que sean, y tengan el origen que
tengan. Por ejemplo, podemos utilizar LINQ para trabajar con bases de
datos, con XML, con Excel, con objetos en memoria
Resumiendo

Pese a que en esta entrada solo hemos hecho una pequeña

introducción con un resumen reducido de las extensiones más
frecuentes que nos aporta LINQ (créeme que muy pequeño... te
recomiendo mirar el espacio de nombres y ver todas sus opciones), es
una herramienta muy potente. Tanto, que otros lenguajes la han
implementado también.

Si bien es cierto que existe una merma de rendimiento respecto a iterar

el bucle directamente, el rendimiento perdido en el 99,99% de los casos
se compensa con el beneficio que aporta tener un código claro, legible
y mantenible.