Novedades en C# 3.0 - Primeros pasos con LINQ
La nueva versión de C# y el framework .NET 3.5 vienen cargadas de novedades, pero sin duda la más atractiva es la inclusión del lenguaje consultas integrado, LINQ. LINQ nos permite homogeneizar el lenguaje y la forma en la que accedemos a los datos independientemente de donde estén ubicados estos.
El objetivo de Microsoft con LINQ es conseguir abstraer al programador de la capa de persistencia de datos, para que pueda programar en un único lenguaje y se centre en el tratamiento de los datos y no en como manipularlos. Me explico, cuando trabajamos con bases de datos relacionales, utilizamos SQL para obtener y manipular los datos, para ello es necesario que el programador conozca SQL. Si trabajamos con XML debemos conocer XQuery-Xpath, y así con cada uno de los posibles repositorios de datos.
La idea que subyace detrás de LINQ es que el programador solo tenga que conocer un único lenguaje y pueda con ese único lenguaje consultar y manipular los datos sin tener que preocuparse de si está trabajando con una base de datos, una colección en memoria, un archivo XML ... En cada caso utilizaremos un proveedores especifico (LINQ to Objects, LINQ to SQL, LINQ to XML ...) pero siempre de forma transparente al programador.
Imaginemos que tenemos obtener, a partir de una colección en memoria que contiene personas, las personas cuya edad sea mayor a cinco años, y que además queremos el resultado ordenado por el nombre y apellidos de la persona. La siguiente consulta LINQ hará el trabajo por nosotros.
var
querypersona = from p in personas
where p.Edad>5orderby p.Nombre, p.Apellido1, p.Apellido2select p;
|
Ya explicaremos más adelante que es el tipo var de retorno de la expresión - de momento solo adelantaremos que no tiene nada que ver con el tipo Variant de Visual Basic.
Otra de las grandes ventajas de trabajar con LINQ es que el compilador valida que la expresión es correcta previniendonos de errores en tiempo de ejecución.
Vamos a hacer un pequeño ejemplo para ilustrar esto, en nuestro caso el proveedor que utilizaremos será LINQ to Objects, que nos permite consultar cualquier array o coleccion que implemente la interfaz IEnumerable<T>. Lo primero es incluir las referencias en nuestro programa - si trabajamos con Visual Studio 2008 se incluyen automáticamente.
using System;using System.Collections.Generic;using System.Linq;using System.Text;
|
Definimos una clase, Persona, muy simple para representar las personas del ejemplo, posteriormente crearemos una colección de personas y ejecutaremos una consulta LINQ.
class
Persona{
public string Nombre { get; set; } public string Apellido1 { get; set; } public string Apellido2 { get; set; } public DateTime FechaNacimiento { get; set; }
public int Edad {get
{ if (FechaNacimiento == null) { throw new Exception ( "Para calcular la edad es necesaria la fecha de nacimiento."); } var dia = DateTime.Now; return (int)dia.Subtract(FechaNacimiento).TotalDays/365;
} } }
|
Obsérvese la nueva forma abreviada de declarar propiedades, otra de las novedades de C# 3.0, es el propio compilador quien se encarga de crear un método privado para encapsular el acceso a la propiedad. Por supuesto podemos seguir escribiendo propiedades como lo hacíamos en versiones anteriores de C#, esta nueva forma es solo "azúcar sintáctico" destinado a facilitarnos la vida.
A continuación, crearemos una coleccion List<T> de personas - que implementa IEnumerable<T> y que por lo tanto nos va a permitir ejecutar consultas LINQ.
List
<Persona> personas = new List<Persona>{
new Persona{ Nombre =
"Pedro",Apellido1 = "Herrarte",Apellido2 = "Apellido 2",FechaNacimiento = new DateTime(1975,5,13)}, new Persona{ Nombre =
"Alicia",Apellido1 = "Alonso",Apellido2 = "Apellido 2",FechaNacimiento = new DateTime(1977, 2,19)}, new Persona{ Nombre =
"Aitor",Apellido1 = "Apellido 1", Apellido2 = "Apellido 2",FechaNacimiento = new DateTime(2003,8,25)}, new Persona{ Nombre =
"Ariana",Apellido1 = "Apellido 1", Apellido2 = "Apellido 2",FechaNacimiento = new DateTime(2007,10,18)} };
|
Otra de las novedades de C# 3.0, la forma de inicializar las colecciones y las clases que la componen. De nuevo mas "azúcar sintáctico".
Una vez que tenemos nuestra colección de Personas ya podemos ejecutar la consulta LINQ, de la siguiente forma.
var
querypersona = from p in personas
where p.Edad>5orderby p.Nombre, p.Apellido1, p.Apellido2select p;
|
Otra novedad es el tipo de retorno de la consulta var, no se trata de un tipo "variant" ni nada por el estilo. Cuando ejecutamos consultas LinQ podemos devolver un tipo existente (como el ejemplo anterior), o un tipo completamente nuevo como en el siguiente ejemplo en el que incluimos una nueva propiedad NombreCompleto - que se construye con una expresión C# (String.Format).
var querypersona = from p in personas where p.Edad>5 orderby p.Nombre, p.Apellido1, p.Apellido2 select new { p.Nombre, p.Apellido1, p.Apellido2, p.Edad, NombreCompleto =
String.Format("{0} {1} {2}", p.Nombre,
p.Apellido1, p.Apellido2) };
|
El tipo de la variable es definido por el compilador en tiempo de compilación, manteniendo así una de la caracteristicas princiapales de C# - ser un lenguaje fuertemente tipado. A este forma de determinar el tipo de una variable se le conoce como "inferencia de tipos".
Nuestro sencillo programa acaba mostrando en pantalla el resultado de nuestra consulta.
foreach
(var p in querypersona){
Console.WriteLine(
"El nombre de la persona es {0}, y su edad es de {1} años.", p.NombreCompleto, p.Edad); } Console.Read();
|
Este articulo es una simple introducción a LINQ y sus posibilidades, se trata de un tema muy amplio y con grandisimas posibilidades que sin duda va a cambiar (para bien) nuestra forma de trabajar con C# y en general con la plataforma .NET. Iremos escribiendo mas cosillas sobre LINQ ...
Saludos, DJK