Tutorial básico de Linq

Hola a todos, en esta oportunidad les daré una introducción extremadamente básica de como utilizar Linq. Bueno primero comencemos con una breve introducción a lo que es Linq, pues bien, Linq (Language Integrated Query) es un lenguaje similar en sintaxis a SQL con la diferencia que podemos utilizar Linq dentro de nuestras aplicaciones .NET, tal vez para muchos les parezca algo feo, incomodo, etc. que hasta hace un año lo era para mí, pues en fin, con un compañero hicimos una aplicación en la que teniamos que utilizar Linq to Sql, en fin, tenñia que aprender Linq y me pareció genial, digo esto porque no me había dado cuenta del poder de consulta de Linq, se pueden hacer consultas a colecciones, arreglos, datasets, documentos xml, etc. me parece increible la forma en cómo se maneja esto, por ejemplo antes de utilizar Linq para filtrar ciertos elementos de un arreglo tenía que recorrerlos, pero con Linq las cosas se hacen con más facilidad. Bueno, Linq aparece en el Dotnet Framework desde su versión tres como una forma de hacer cálculo lambda, el mismo que podemos utilizar en lenguajes como Python por ejemplo.


Para comenzar y se darán cuenta que a lo largo de los ejemplos se utilizará la palabra clave "var" la cual indica que la variable que es seguida por "var" es un tipo de dato anónimo, por esto entendemos que no tenemos que especificar el tipo, al definir "var" el compilador analizará el tipo de dato, y podremos utilizarlo como lo que es en lo que resta de la aplicación.

var x = "hola a mundo";
// Desde este punto podemos usar x como string
var y = new Persona();
// Desde este punto podemos usar y 
// como objeto de tipo persona
y.Morir();

Bueno, y por que utilizar var en vez de string o cualquier otro tipo de dato, pues bien, más adelante mientras vayamos construyendo nuestras consultas con Linq, veremos que los tipos de datos resultantes serán indefinidos, con esto me refiero a que podemos definir tipos que ni siquiera existen en nuestro contexto:

var undef = new {Color="Azul", Modelo=1995};

Pero todo tiene un costo, estos elementos indefinidos se vuelven inmutables, con esto me refiero a que no podemos modificar sus valores, si intentáramos hacer:

var undef = new {Color="Azul", Modelo=1995};
undef.Color = "Verde";

Este código nos generaría un error de compilación.


El anterior ejemplo es un tipo indefinido, pero también son llamados tipos de datos compuestos ya que estos están compuestos por otros datos, en este caso una cadena Color y un entero Modelo; en este ejemplo definimos un tipo compuesto, pero solo sus campos, en el caso que quisiéramos adicionarle alguna funcionalidad, lo podemos hacer a través de Func, que es un delegado para tipos anónimos:

static void PruebaFunc() {
   Func convertir = delegate(int input) {
       return "Año: " + input;
   };
   var undef = new {Color="Azul", Modelo=1995, Mostrar=convertir};
   // Llamamos a la funcion mostrar
   string nuevoModelo = undef.Mostrar(undef.Modelo);
   Console.WriteLine(nuevoModelo);
}

La explicación del anterior código fuente es la siguiente, primero definimos un delegado anónimo, el cual recibirá un parámetro int y devolverá un string, luego realizamos la lógica como nosotros queramos, luego creamos nuestro tipo compuesto, y adicionamos un nuevo campo Mostrar que hace referencia al delegado anónimo que acabamos de crear, luego lo llamamos de la manera en la que sabemos, "undef.Mostrar(undef.Modelo);". Hay que notar que en la parte de definición del delegado anónimo el último tipo de dato es el tipo de dato de retorno, por ejemplo Func significa que el cuerpo del delegado debe retornar un tipo string y admitir dos parámetros de tipo entero, en el caso de que haya un único parámetro Func, significa que el cuerpo del delegado debe devolver un objeto de tipo string, pero no tendrá ningún parámetro de entrada.

Creo que hasta aquí con tipos y métodos anónimos, ahora vayamos a lo que nos interesa, hacer consultas utilizando Linq. Pues bien, hacer una consulta utilizando Linq es simple, es como escribir una consulta SQL pero con algunas cambios en el orden de las sentencias. Para ilustrar esto, imaginen que tenemos una tabla llamada Personas con los campos {Codigo, Nombre, Edad}, bueno para desplegar por ejemplo los datos de las personas que tengan la edad menor a 18 años tendríamos una consulta sql similar a la siguiente:

SELECT Codigo, Nombre, Edad
FROM Personas
WHERE Edad < 18

Pues bien, esto nos servirá para obtener los datos solo dentro de la base de datos, ahora imaginen que por falta de recursos, o simplemente un proyecto no amerita utilizar un motor de base de datos, si no un documento XML o un archivo binario, etc. La forma en la que comúnmente utilizaríamos para representar la misma consulta sería:

List personas = DbHelper.GetPersona();
List result = new List();
foreach(Persona p in Persona) {
   if(p.Edad < 18)
      result.Add(p);
}

Pues, bien como les dije hacer consultas Linq es como hacer una consulta SQL pero con cambios en el orden de las sentencias, para hacer el anterior trabajo, utilizando Linq quedaría de la siguiente forma:

List personas = DbHelper.GetPersona();
var result = from p in persona where p.Edad < 18 select p;

Ahora, analicemos el código, bueno simplemente la línea que nos permite hacer esto se podría leer como lo siguiente: "Sea una variable p, que este en la lista de personas, donde las edad de esta persona sea 18, entonces la utilizamos". Ahora la variable result tendrá una colección de datos los cuales podemos recorrerlos, etc.

Como habrán notado, es como hacer una consulta sql con diferente orden, pues bien, de la misma forma que en SQL podemos hacer Joins, Unions, etc., por ejemplo dado un arreglo quisiéramos guardar la suma de sus elementos anteriores de tal forma que si tenemos:

{1,2,3,4,5,6,7,8,9,10} tengamos la sumatoria de los elementos hasta ese elementos {1,3,6,10,15,21,28,36,45,55}

int[] V1 = new int[] { 1,2,3,4,5,6,7,8,9,10 };
int s = 0;
var tmp = from x in V1 select s+=x;
            
foreach(int t in tmp) {
    Console.Write(t + " ");
}

La ventaja de utilizar Linq es la de poder hacer consultas a cualquier tipo de objeto que tengamos en .Net, pueden ser colecciones, Datasets, etc de esta forma no solo tenemos que hacer consultas a bases de datos, obviamente esto nos facilita mucho el trabajo para hacer filtros, etc.

Bueno, al ser este un tutorial básico para dar una noción de lo que es Linq, existen muchas otras cosas que se tienen que considerar como el cálculo lambda, otras funciones de arreglos Union, Agregate, SkipWhile, etc. Ahora si queremos trabajar con bases de datos, podemos utilizar LinqToSql que es un ORM que nos permite trabajar con bases de datos con mayor facilidad.

Creo que eso es todo para este tutorial que como les digo es extremadamente básico, solo lo hice con el propósito de mostrarles esta tecnología. En fin, más adelante espero hacer mas de estos tutoriales para ir mostrándoles paso a paso todo lo relacionado a Linq.

Saludos