Seminario de LINQ

Docente
Ing. Kirio Marvin Ventura
 ¿Que es LINQ?
LINQ o Language INtegrated Query es una de las novedades más importantes de
Microsoft .NET Framework 3.5 y que afecta por lo tanto a Visual Studio 2010 y con ello
los lenguajes usados, entre los que está el que usaremos que es Visual C# 2010.

Arquitectura interna del modelo LINQ

 Introducción a LINQ
• Language-Integrated Query (LINQ) es el nombre de un conjunto de
tecnologías que consiste en la integración directa de funciones de
consulta en el lenguaje C# (también en Visual Basic y
potencialmente en cualquier otro lenguaje de .NET). Con LINQ,
ahora una consulta es una construcción de lenguaje de primera
clase, igual que las clases, los métodos, los eventos, etc.

• Al usar sintaxis de consulta, se pueden realizar operaciones

complejas de filtrado, ordenación y agrupamiento en orígenes de
datos con código mínimo. Los mismos patrones de expresión de
consulta básicos se usan para consultar y transformar datos de
bases de datos SQL, conjuntos de datos de ADO.NET, secuencias y
documentos XML, y colecciones de .NET.

Nota: LINQ no está disponible en Visual Studio 2005 ni versiones anteriores

 Orígenes de datos LINQ
• Para trabajar con colecciones, datos y elementos con LINQ, Microsoft
ha proporcionado una serie de objetos o extensiones que nos
permitirán interactuar con los datos adecuados y LINQ.

• Como se pudo ver en la arquitectura de LINQ, los lenguajes de

programación están en la capa más alta, y a continuación LINQ como
lenguaje integrado de consultas, y debajo de éste, los orígenes de
datos o extensiones que podremos utilizar con LINQ.

• Respecto a las extensiones, debemos destacar las que pertenecen a

los objetos de datos relaciones, las que tienen relación con los objetos
propiamente dichos, y las que permiten trabajar con XML. Todos estos
extensores, nos permiten trabajar con LINQ de una forma muy
parecida.
 Extensores de LINQ
Así por lo tanto, tenemos dentro de .NET Framework 3.5 los siguientes
extensores:

Estos extensores son LINQ to DataSet, también conocido como LINQ sobre
conjunto de datos, LINQ to SQL para trabajar con bases de datos SQL Server y
LINQ to Entities para trabajar con entidades, o lo que es lo mismo, con
cualquier fuente de datos, no solo con SQL Server.
 LINQ to Objects
• Con LINQ to Objects trabajaremos con objetos,
matrices y colecciones de datos que están en memoria,
desde nuestras aplicaciones escritas en Visual C#.

• También podemos trabajar con LINQ siempre y

cuando los objetos con los que queremos trabajar,
implementen las interfaces IEnumerable e
IEnumerable<T>.

• Para recorrer los elementos de una colección,

utilizaremos normalmente el bucle For Each.
 Las tres partes de una operación de
consulta LINQ
Todas las operaciones de consulta LINQ se
componen de tres acciones distintas:

1. Obtención del origen de datos.

2. Creación de la consulta.

3. Ejecución de la consulta.
 Como utilizar LINQ to Objects
En este primer ejemplo se muestra cómo se expresan las tres partes de una
operación de consulta en el código fuente. Este mismo concepto se aplica a
otros orígenes de datos.
class IntroDeLINQ
{
static void Main()
{
// Las 3 Partes de una consulta LINQ:
// 1. Origen de Datos.
int[] numeros = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

// 2. Creación de la Consulta.
// numQuery es un IEnumerable<int>
var numQuery =
from num in numeros
where (num % 2) == 0
select num;

// 3. Ejecución de la consulta.
foreach (int num in numQuery)
{
Console.Write("{0,1} ", num);
}
}
}
 Como utilizar LINQ to Objects
En la siguiente ilustración se muestra la operación de consulta completa. En LINQ,
la ejecución de la consulta es distinta de la propia consulta; en otras palabras, no
se recuperan datos con la simple creación de la variable de consulta.
 Como utilizar LINQ to Objects
En este otro ejemplo, se muestra cómo trabajar usando una matriz de datos. Es un
sencillo ejemplo que nos permite comprender mejor como funciona LINQ to Objects.
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{ // Declaramos la matriz y la inicializamos con valores
string[] material = {"mesa","reloj", "libro", "pluma", "borrador", "pelota", "botella"};
// Ejecutamos LINQ para obtener los datos buscados, concretamente los materiales que empiezan por "b"
var materialBuscado = from busqueda in material
where busqueda.StartsWith("b")
select busqueda;
string resultado = "";
foreach (var elementos in materialBuscado)
{
resultado += elementos + "\r\n";
} // Mostramos la información
MessageBox.Show(resultado);
}
}
 LINQ to XML
• Con LINQ to XML trabajaremos con documentos
XML desde nuestras aplicaciones escritas en Visual C#
2010.

• Lo más destacable de LINQ to XML es la posibilidad

que nos brinda el entorno de trabajar con
documentos XML e información en formato XML.

• Para trabajar con LINQ to XML, Microsoft ha

proporcionado un nuevo ensamblado de nombre
System.Linq.Xml.dll.
 Como utilizar LINQ to XML
A continuación, observe un ejemplo de como trabajar con LINQ to XML.
Para este ejemplo, se requiere el siguiente documento XML:
<?xml version='1.0'?>
<!-- Este documento XML representa un inventario de autos -->
<autos>
<auto marca="BMW">
<modelo>520</modelo>
<potencia>125CV</potencia>
</auto>
<auto marca="BMW">
<modelo>525</modelo>
<potencia>135CV</potencia>
</auto>
<auto marca="Citroen">
<modelo>C3</modelo>
<potencia>75CV</potencia>
</auto>
<auto marca="Citroen">
<modelo>C4</modelo>
<potencia>115CV</potencia>
</auto>
<auto marca="Citroen">
<modelo>C5</modelo>
<potencia>135CV</potencia>
</auto>
</autos>
 Como utilizar LINQ to XML… cont
Basándonos en la base del documento anterior, se muestra el siguiente
ejemplo que utiliza el documento XML indicado anteriormente:
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
XDocument documentoXML = XDocument.Load(@"C:\Autos.xml");
var datosSeleccionados = from datos in documentoXML.Descendants(“auto")
where datos.Attribute("marca").Value.ToString().ToUpper() == "BMW"
select new
{
modeloAuto = datos.Element("modelo").Value,
potenciaAuto = datos.Element("potencia").Value
};
string resultado = "";
foreach (var dato in datosSeleccionados)
{
resultado += String.Format("{0} tiene un auto {1} de {2} CV", "BMW", dato.modeloAuto, dato.potenciaAuto) + "\r\n";
}
// Mostramos la información
MessageBox.Show(resultado);
}
}
 LINQ y ADO.NET
Hasta el momento, se ha visto como trabajar con LINQ to Objects y LINQ to XML, sin
embargo, aún no se ha visto como trabajar con fuentes de datos y LINQ.
Como puede observar la parte que corresponde al trabajo con LINQ y ADO.NET, está
constituida por tres proveedores que nos permiten trabajar con datos:
 LINQ to DataSet
• LINQ to DataSet nos ofrece la posibilidad de trabajar con LINQ
y fuentes de datos desconectadas, o lo que es lo mismo, usar
LINQ para manipular y trabajar con los datos de un DataSet.

• Para trabajar con LINQ y DataSet, no debemos pensar en nuevo

paradigma de trabajo y manipulación de los datos, sino de
pensar en LINQ como un servicio más que se ofrece para
trabajar con DataSet.

• La única regla de oro no obstante, es que los DataSet con los

que trabajaremos, serán DataSet tipados, es decir, DataSet que
poseen unos tipos de datos establecidos.
 Como utilizar LINQ to DataSet
En el siguiente ejemplo, veremos como utilizar LINQ to DataSet. Para ello, crearemos un DataSet
que haga referencia a una tabla de Personas en una base de datos con una serie de valores
predeterminados. Posteriormente, utilizaremos LINQ para acceder a los datos del DataSet. El
ejemplo, quedará de la siguiente forma:
public partial class Form1 : Form
{
private void button1_Click(object sender, EventArgs e)
{ // Creamos el DataSet y para efectos prácticos se ha omitido la conexión a la base de datos y el llenado de datos al DataSet.
DataSet personasDataSet = new DataSet();
// Buscamos datos dentro del DataSet
var datosBuscados = from datos in personasDataSet.Tables["TablaPersonas"].AsEnumerable()
where System.Convert.ToInt16(datos.Field<string>("Edad")) > 25
select new
{
nombre = datos.Field<string>("Nombre"),
flagSexo = ((datos.Field<string>("Sexo") == "hombre") ? true : false ),
sexo = datos.Field<string>("Sexo")
};
// Mostramos los datos
string resultado = "";
foreach (var dato in datosBuscados)
{
resultado += string.Format("{0} es {1} {2}", dato.nombre, ((dato.flagSexo) ? "un" : "una"), dato.sexo) + "\r\n";
}
MessageBox.Show(resultado);
}
}
 LINQ to SQL
Usaremos LINQ to SQL ó LINQ to Entities si queremos
trabajar con fuentes de datos conectadas.

¿Cuál de ellos debemos utilizar?.

LINQ to Entities está preparado para trabajar con

cualquier fuente de datos conectada, mientras que
LINQ to SQL está preparada para trabajar únicamente
con fuentes de datos Microsoft SQL Server, por lo que
parece claro, que si tenemos un motor de base de
datos como Microsoft SQL Server, podemos trabajar
tanto con LINQ to SQL como con LINQ to Entities.
 LINQ to SQL… cont
¿Sentencias LINQ o sentencias SQL?

LINQ to SQL destaca por permitirnos trabajar con objetos

relacionales (O/R) a través del diseñador que ha sido
incluido en Visual Studio 2010. Adicionalmente, LINQ to
SQL tiene la habilidad de construir la instrucción SQL
correspondiente.

El programador debe olvidarse de como construir esa

sentencia SQL, ya que es el propio compilador y el motor de
ejecución de .NET Framework, el que se encarga de crear y
lanzar por nosotros la sentencia SQL correspondiente.
 Práctica de LINQ to SQL
Para practicar con LINQ to SQL deberemos iniciar Visual Studio 2010. En concreto, iniciaremos un proyecto de
formulario Windows e insertaremos un control Button y un control DataGridView dentro del formulario.
Una vez hecho esto, haremos clic sobre el proyecto con el botón derecho del ratón y elegir la opción “agregar”
luego en “nuevo elemento”, y aparecerá una ventana dentro de la cual, deberemos seleccionar la plantilla
Clases de LINQ to SQL perteneciente a la categoría Datos. Esto es lo que se puede ver en la siguiente imagen:
 Práctica de LINQ to SQL… cont
Una vez seleccionada esta plantilla, el
proyecto mostrará una nueva ventana que
corresponde con el diseñador del modelo
relacional, donde deberemos indicar que
partes del modelo de datos de SQL Server
queremos incluir en la plantilla.

A continuación, deberemos realizar la

siguiente tarea, que consiste en crear una
conexión con la base de datos de SQL
Server. Para ello, podemos utilizar el
Explorador de servidores y agregar en él la
conexión que queremos utilizar en LINQ to
SQL.

Cuando hayamos agregado la conexión con

la base de datos, y dentro de la ventana
del Explorador de servidores, podremos
arrastrar y soltar sobre el diseñador, los
objetos del modelo de datos que
queramos utilizar en LINQ to SQL.
 Práctica de LINQ to SQL… cont
En el ejemplo con el que vamos a trabajar, los objetos que hemos arrastrado
y soltado sobre el diseñador, son los que se muestran en la siguiente figura:

Como podemos ver en la figura anterior, el diseñador del modelo relacional

de LINQ to SQL, muestra en este caso, dos tablas y su posible relación. Las
tablas contienen además, datos con los que podremos operar o trabajar. Aquí
es donde entra LINQ y donde usándolo, obtendremos una gran productividad
en nuestros desarrollos.
 Práctica de LINQ to SQL… cont
Para finalizar nuestro ejemplo, escribiremos el siguiente código fuente en el evento clic del
botón:
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
// Declaramos el contexto
DataClasses1DataContext contexto = new DataClasses1DataContext();
// Ejecutamos la sentencia LINQ correspondiente
var datos = from tablaPropietario in contexto.Propietarios
from tablaAutos in contexto.Autos
where tablaAutos.Placa == tablaPropietario.Placa
group tablaAutos by tablaPropietario.Dui into autos
select new
{
DUI = autos.Key,
Cantidad = autos.Count()
};
// Mostramos el resultado final
this.dataGridView1.DataSource = datos;
}
}
 Práctica de LINQ to SQL… cont
Nuestro ejemplo en ejecución, es el que se muestra en la figura siguiente:

Como pudimos apreciar en el código fuente de la aplicación que hemos

escrito, la cantidad de código fuente que hemos agregado es realmente
pequeña. Analizando nuestro código fuente, vemos que por un lado, hemos
declarado el contexto, o lo que es lo mismo, la clase del modelo relacional
que hemos construido (el archivo de extensión dbml).
 Práctica de LINQ to SQL… cont
¿Dónde se encuentra la cadena de conexión para conectarse a la fuente de datos?.
La cadena de conexión la encontraremos en la configuración de la aplicación. Para acceder a ella,
deberemos hacer clic con el botón derecho del ratón sobre el proyecto, y seleccionar la opción
Propiedades del menú emergente. Finalmente, accederemos a la pestaña Configuración para
acceder al valor de la cadena de conexión que utiliza LINQ to SQL para conectarse.
Esto es lo que se puede ver en la siguiente imagen:
 ¡GRACIAS!
Para más información visite:
http://msdn.microsoft.com/es-es/library/bb397676.aspx