Linq: Nunca es tarde para aprender

Sin duda, debería haberme subido al tren de Linq hace muchísimo tiempo pero mas vale tarde que nunca. Hoy me propongo iniciar mi aprendizaje de Linq, y estaré posteando a diario mis avances, con la esperanza de que lo que escriba aquí le sea útil a alguien que, aunque tarde como yo, quiere iniciarse en esta tecnología.

Estoy usando el libro "Linq for Visual C# 2005" de Fabio Claudio Ferracchiati, un libro de poco más de 170 páginas, que nos servirá por lo menos para dominar los rudimentos, para luego pasar a cosas más avanzadas.

Primero lo primero: Necesitamos datos que podamos consultar.

Linq puede consultar datos de diversas fuentes como objetos en memoria (Linq to Objects), bases de datos SQL, Ficheros XML entre otros. Empezaré usando Linq To Objects hasta dominar la sintaxis y luego (pronto, espero) pasaré a experimentar con las otras fuentes de datos.

Empecemos definiendo una sencilla clase Persona:

public class Persona
{
   private int id;
   private int idRol;
   private string apellido;
   private string nombre;
    public string Apellido
   {
        get { return apellido; } 
        set { apellido = value; }
   }
    public string Nombre
   {
       get { return nombre; }
       set { nombre = value; }
   }

   public int IdRol
   {
       get { return idRol; }
       set { idRol = value; }
   }
    public int Id
   {
        get { return id; }
        set { id = value; }
   }
    public Persona(int id, int idRol, string apellido, string nombre)
   {
        this.Id = id;
        this.IdRol = idRol;
        this.Apellido = apellido;
        this.Nombre = nombre;
   }
}

Posteriormente extenderemos esta clase y añadiremos otras, pero por el momento nos sirve tal cual está.

Para que nuestros objetos puedan ser consultados mediante Linq, deben implementar la interface IEnumerable, por lo que podemos crear una lista de Personas y aprovechamos para poblarla con algunos elementos:

personas= new List<Persona>();
personas.Add(new Persona(1, 1, "Anderson", "Brad"));
personas.Add(new Persona(2, 2, "Gray", "Tom"));
personas.Add(new Persona(3, 2, "Perez", "Juan"));
personas.Add(new Persona(3, 3, "Morales", "Pedro"));

Ya estamos listos para empezar a consultar los datos usando Linq. Una consulta realmente simple es:

var query = from p
in personas
select p;

Hay mucho que explicar en esta simple consulta.

1. var: El .NET Framework incluye un nuevo tipo de datos denominado var, que significa Variant. Es una variable local implícitamente tipada, o sea que adopta un tipo determinado de acuerdo al contexto.
   
2. from p in personas select p: Si manejamos SQL notaremos la similitud inmediatamente, pues en SQL escribiríamos SELECT * FROM Personas. En Linq primeramente especificamos a (o las) fuentes de las que extraeremos nuestros datos, en este caso "personas" que es una lista. En algún lugar leí que se decidió poner el datasource (la claúsula from) en primer lugar (a diferencia de SQL) con el fin de dar soporte a cosas tales como IntelliSense, imagino que también existen otras razones. La variable "p" representa un objeto dentro de la colección "personas".
   
3. Select p: Esta claúsula equivale a SELECT * de SQL, es decir: "Recuperar todos los campos".
   
   

Asi de fácil, con esas 3 lineas, obtenemos todos los elementos de la colección personas y asignamos el resultado a la variable query.

Podemos ver los resultados de nuestra consulta asignando la variable query que hemos obtenido a un bindingSource, asi:

bindingSource1.DataSource = query;

entonces podremos visualizar inmediatamente los resultados en un DataGridView, por ejemplo. No olvidar fijar la propiedad AutoGenerateColumns a true.

Un par de consultas más, a manera de ejemplo:

var query = from p
in personas

select new { p.Apellido, p.Nombre};

Esta consulta nos permite seleccionar únicamente los campos que nos interesan, en este caso, el apellido y el nombre.

Por último,

var query = from p
in personas
where p.Id == 1
select new { p.Apellido, p.Nombre };

Como se puede suponer, la cláusula where nos permite seleccionar únicamente aquellos elementos que cumplen una determinada condición. Podemos utilizar cualquier combinación de expresiones booleanas que el .NET framework nos permita, eso nos permitirá construir consultas muy complejas.

Hasta aquí llegamos con esta breve introducción.