Download - LABO03 - LINQ DRAI

Facultad de Ingenieras y ArquitecturaEscuela Profesional de Ingeniera de Sistemas e Informtica

LABORATORIO DE DESARROLLO RAPIDO DE APLICACIONES PARAINTERNET Pgina: 1/24

Sesin Nro. 3 Fecha:

Tema: LINQ Ciclo: VISeccin:

Docentes: Ing. Anbal Sardn Paniagua Ciclo Acd. 2014-1B

Alumno: Nota:

OBJETIVOS: Conocer los conceptos bsicos de LINQ. Descubrir la sintaxis de LINQ. Conocer el manejo de LINQ y los tipos genricos.

REQUISITOS: Sistema Operativo Windows MS Visual Studio 2010 Pizarra. Plumn, mota

INFORMACIN:

INTRODUCCIN A LINQ

Language-Integrated Query (LINQ) es una innovacin introducida en Visual Studio 2008 y .NET Framework

versin 3.5 que elimina la distancia que separa el mundo de los objetos y el mundo de los datos.

Tradicionalmente, las consultas con datos se expresan como cadenas sencillas, sin comprobacin de tipos en

tiempo de compilacin ni compatibilidad con IntelliSense.

Adems, es necesario aprender un lenguaje de consultas diferente para cada tipo de origen de datos: bases de

datos SQL, documentos XML, servicios Web diversos, etc.

LINQ convierte una consulta en una construccin de lenguaje de primera clase en C# y Visual Basic. Las

consultas se escriben para colecciones de objetos fuertemente tipadas, utilizando palabras clave del lenguaje y

operadores con los que se est familiarizado.

La ilustracin siguiente muestra una consulta LINQ parcialmente completada en una base de datos SQL Server

en C#, con comprobacin de tipos completa y compatibilidad con IntelliSense.

PDF Creator - PDF4Free v3.0 http://www.pdf4free.com



En Visual Studio se pueden escribir consultas LINQ en Visual Basic o en C# con bases de datos SQL Server,

documentos XML, conjuntos de datos ADO.NET y cualquier coleccin de objetos que admita IEnumerable o lainterfaz genrica IEnumerable.Tambin se ha previsto la compatibilidad de LINQ con ADO.NET Entity Framework, y otros fabricantes seencuentran escribiendo proveedores LINQ para muchos servicios Web y otras implementaciones de bases de

datos.

Puede utilizar consultas LINQ en proyectos nuevos o junto a consultas que no son LINQ en proyectos existentes.

El nico requisito es que el proyecto est orientado a .NET Framework 3.5 o posterior.




1. INTRODUCCIN A LAS CONSULTAS LINQ (C#)

Una consulta es una expresin que recupera datos de un origen de datos. Las consultas normalmente se

expresan en un lenguaje de consultas especializado. A lo largo del tiempo se han ido desarrollando lenguajes

diferentes para los distintos tipos de orgenes de datos, como SQL para las bases de datos relacionales y

XQuery para XML. Por tanto, los desarrolladores han tenido que aprender un nuevo lenguaje de consulta para

cada tipo de origen de datos o formato de datos que deben usar.

LINQ simplifica esta situacin al proporcionar un modelo coherente para trabajar con los datos de varios tipos de

formatos y orgenes de datos.

En una consulta LINQ, siempre se trabaja con objetos. Se utilizan los mismos modelos de codificacin bsicos

para consultar y transformar datos de documentos XML, bases de datos SQL, conjuntos de datos ADO.NET,colecciones .NET y cualquier otro formato para el que haya disponible un proveedor LINQ..

Todas las operaciones de consulta LINQ se componen de tres acciones distintas:

1. Obtencin del origen de datos.

2. Creacin de la consulta.

3. Ejecucin de la consulta.

En el ejemplo siguiente se muestra cmo se expresan las tres partes de una operacin de consulta en el

cdigo fuente. En el ejemplo se utiliza por comodidad una matriz de enteros como origen de datos, pero los




mismos conceptos se aplican a otros orgenes de datos.

class IntroToLINQ{

static void Main(){

// The Three Parts of a LINQ Query:// 1. Data source.int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

// 2. Query creation.// numQuery is an IEnumerablevar numQuery =

from num in numberswhere (num % 2) == 0select num;

// 3. Query execution.foreach (int num in numQuery){

Console.Write("{0,1} ", num);}

}}

En la siguiente ilustracin se muestra la operacin de consulta completa. En LINQ, la ejecucin de la consulta es

distinta de la propia consulta; en otras palabras, no se recuperan datos con la simple creacin de la variable de

consulta.

.

2. EL ORIGEN DE DATOS




En el ejemplo anterior, como el origen de datos es una matriz, se admite implcitamente la interfaz genrica

IEnumerable. Este hecho implica que se puede consultar con LINQ. Una consulta se ejecuta en unainstruccin foreach y foreach necesita IEnumerable o IEnumerable.Los tipos que admiten IEnumerable o una interfaz derivada, como la genrica IQueryable, sedenominan tipos consultables.

Un tipo que se puede consultar no requiere ninguna modificacin o tratamiento especial para servir como origen

de datos LINQ.

Si los datos de origen an no estn en memoria como tipo que se puede consultar, el proveedor LINQ debe

representarlos como tales.

Por ejemplo, LINQ to XML carga un documento XML en un tipo XElement que se puede consultar:

// Create a data source from an XML document.// using System.Xml.Linq;XElement contacts = XElement.Load(@"c:\myContactList.xml");

Con LINQ to SQL, primero se crea una asignacin relacional de objetos en tiempo de diseo, ya sea

manualmente o mediante el Object Relational Designer (O/R Designer). Despus, se escriben las consultas en

los objetos y, en tiempo de ejecucin, LINQ to SQL controla la comunicacin con la base de datos. En el ejemplo

siguiente, Customers representa una tabla concreta de la base de datos y el tipo del resultado de la consulta,IQueryable, se deriva de IEnumerable.

Northwnd db = new Northwnd(@"c:\northwnd.mdf");

// Query for customers in London.IQueryable custQuery =

from cust in db.Customerswhere cust.City == "London"select cust;

3. EJECUCIN DE LA CONSULTA

3.1 Ejecucin diferida

Como se ha mencionado previamente, la variable de consulta slo almacena los comandos de la consulta. La

ejecucin real de la consulta se aplaza hasta que se procese una iteracin en la variable de consulta, en una

instruccin foreach. Este concepto se conoce como ejecucin diferida y se muestra en el ejemplo siguiente:

// Query execution.foreach (int num in numQuery){

Console.Write("{0,1} ", num);}




La instruccin foreach es tambin donde se recuperan los resultados de la consulta. Por ejemplo, en la

consulta anterior, la variable de iteracin num contiene cada valor (de uno en uno) en la secuencia devuelta.

Dado que la propia variable de consulta nunca contiene los resultados de la consulta, se puede ejecutar

tantas veces como se desee. Por ejemplo, puede que una aplicacin independiente actualice continuamente

una base de datos. En su aplicacin, podra crear una consulta que recuperase los datos ms recientes, y

podra ejecutarla repetidamente cada cierto tiempo para recuperar cada vez resultados diferentes.

3.2 Forzar la ejecucin inmediata

Las consultas que realizan funciones de agregacin en un intervalo de elementos de origen primero deben

recorrer en iteracin dichos elementos. Algunos ejemplos de esas consultas son Count, Max, Average yFirst. Se ejecutan sin una instruccin foreach explcita porque la propia consulta debe utilizar foreach para

devolver un resultado. Debe saber tambin que estos tipos de consultas devuelven un solo valor, no una

coleccin IEnumerable. La consulta siguiente devuelve un recuento de los nmeros pares de la matriz de

origen:

var evenNumQuery =from num in numberswhere (num % 2) == 0select num;

int evenNumCount = evenNumQuery.Count();

Para forzar la ejecucin inmediata de cualquier consulta y almacenar en memoria cach sus resultados,

puede llamar al mtodo ToList o ToArray.

List numQuery2 =(from num in numberswhere (num % 2) == 0select num).ToList();

// or like this:// numQuery3 is still an int[]

var numQuery3 =(from num in numberswhere (num % 2) == 0select num).ToArray();

Tambin puede forzar la ejecucin si coloca el bucle foreach justo despus de la expresin de consulta. Sin




embargo, al llamar a ToList o ToArray tambin se almacenan en memoria cach todos los datos en un

objeto de coleccin nico.

4. LINQ Y TIPOS GENRICOS (C#)

Las consultas LINQ se basan en tipos genricos, que se incluyeron por primera vez en la versin 2.0 de .NET

Framework. No se requieren conocimientos avanzados de los tipos genricos para poder empezar a escribir

consultas. Sin embargo, quizs necesite conocer dos conceptos bsicos:

1. Al crear una instancia de una clase de coleccin genrica, como List, la "T" se reemplaza con el tipo

de objetos que contendr la lista.

Por ejemplo, una lista de cadenas se expresa como List y una lista de objetos Customer seexpresa como List.

Una lista genrica est fuertemente tipada y proporciona muchas ventajas frente a las colecciones que

almacenan sus elementos como Object. Si intenta agregar Customer a List, obtendr un error en

tiempo de compilacin.

Es fcil utilizar las colecciones genricas, porque no es necesario realizar conversiones de tipos en tiempo

de ejecucin.

2. IEnumerable es la interfaz que permite enumerar las clases de coleccin genricas mediante lainstruccin foreach. Las clases de coleccin genricas admiten IEnumerable de la misma forma que

las clases de coleccin no genricas, como ArrayList, admiten IEnumerable.

4.1 Variables IEnumerable en consultas LINQ

Las variables de consulta LINQ tienen tipos IEnumerable o un tipo derivado, como IQueryable.Cuando se encuentre una variable de consulta de tipo IEnumerable, slo significa que la

consulta, cuando se ejecute, generar una secuencia de cero o ms objetos Customer.

IEnumerable customerQuery =from cust in customerswhere cust.City == "London"select cust;

foreach (Customer customer in customerQuery){

Console.WriteLine(customer.LastName + ", " + customer.FirstName);}




4.2 Permitir al compilador administrar las declaraciones de tipos genricos

Si lo prefiere, puede evitar la sintaxis genrica con el uso de la palabra clave var. La palabra clave var indicaal compilador que deduzca el tipo de una variable de consulta examinando el origen de datos especificado en

la clusula from. En el ejemplo siguiente se genera el mismo cdigo compilado que en el ejemplo anterior:

var customerQuery2 =from cust in customerswhere cust.City == "London"select cust;

foreach(var customer in customerQuery2){

Console.WriteLine(customer.LastName + ", " + customer.FirstName);}

La palabra clave var es til cuando el tipo de la variable es obvio o cuando no es tan importante especificar

explcitamente los tipos genricos anidados, como los que se generan en las consultas de grupo. Por lo

general, si utiliza var, debe saber que puede dificultar la legibilidad del cdigo para los dems.

5. OPERACIONES BSICAS DE CONSULTA LINQ (C#)

5.1 Obtener un origen de datos

En una consulta LINQ, el primer paso es especificar el origen de datos. En C#, como en la mayora de los

lenguajes de programacin, se debe declarar una variable antes de poder utilizarla. En una consulta LINQ, la

clusula from aparece en primer lugar para introducir el origen de datos (customers) y la variable de rango

(cust).

//queryAllCustomers is an IEnumerablevar queryAllCustomers = from cust in customers

select cust;

La variable de rango es como la variable de iteracin en un bucle foreach, con la diferencia de que en una

expresin de consulta realmente no se produce ninguna iteracin. Cuando se ejecuta la consulta, la variable

de rango acta como referencia para cada elemento sucesivo de customers. Dado que el compilador puede

deducir el tipo de cust, no tiene que especificarlo explcitamente. Una clusula let puede introducir variables

5.2 Filtrar

Probablemente la operacin de consulta ms comn es aplicar un filtro en forma de expresin booleana. El




filtro hace que la consulta devuelva slo los elementos para los que la expresin es verdadera. El resultado

se genera mediante la clusula where. El filtro aplicado especifica qu elementos se deben excluir de la

secuencia de origen. En el ejemplo siguiente, slo se devuelven los customers cuya direccin se encuentra

en Londres (London).

var queryLondonCustomers = from cust in customerswhere cust.City == "London"select cust;

Puede utilizar los operadores lgicos AND y OR de C#, con los que ya estar familiarizado, para aplicar las

expresiones de filtro que sean necesarias en la clusula where. Por ejemplo, para devolver slo los clientes

con direccin en "London" AND cuyo nombre sea "Devon", escribira el cdigo siguiente:

where cust.City=="London" && cust.Name == "Devon"

Para devolver los clientes con direccin en Londres o Pars, escribira el cdigo siguiente:

where cust.City == "London" || cust.City == "Paris"

5.3 Ordering

A menudo es necesario ordenar los datos devueltos. La clusula orderby har que los elementos de lasecuencia devuelta se ordenen segn el comparador predeterminado del tipo que se va a ordenar. Por

ejemplo, la consulta siguiente se puede extender para ordenar los resultados segn la propiedad Name. Dado

que Name es una cadena, el comparador predeterminado realiza una ordenacin alfabtica de la A a la Z.

var queryLondonCustomers3 =from cust in customerswhere cust.City == "London"orderby cust.Name ascendingselect cust;

Para ordenar los resultados en orden inverso, de la Z a la A, utilice la clusula orderbydescending.

5.4 Grupo

La clusula group permite agrupar los resultados segn la clave que se especifique. Por ejemplo, podra




especificar que los resultados se agrupen por City para que todos los clientes de London o Pars estn en

grupos individuales. En este caso, la clave es cust.City.

// queryCustomersByCity is an IEnumerablevar queryCustomersByCity =

from cust in customersgroup cust by cust.City;

// customerGroup is an IGroupingforeach (var customerGroup in queryCustomersByCity){

Console.WriteLine(customerGroup.Key);foreach (Customer customer in customerGroup){

Console.WriteLine(" {0}", customer.Name);}

}

Al finalizar una consulta con una clusula group, los resultados adoptan la forma de una lista de listas. Cada

elemento de la lista es un objeto que tiene un miembro Key y una lista de elementos agrupados bajo esa

clave. Al procesar una iteracin en una consulta que genera una secuencia de grupos, debe utilizar un bucle

foreach anidado. El bucle exterior recorre en iteracin cada grupo y el bucle interior recorre en iteracin los

miembros de cada grupo.

Si debe hacer referencia a los resultados de una operacin de grupo, puede utilizar la palabra clave into para

crear un identificador con el que se puedan realizar ms consultas. La consulta siguiente devuelve slo los

grupos que contienen ms de dos clientes:

// custQuery is an IEnumerablevar custQuery =

from cust in customersgroup cust by cust.City into custGroupwhere custGroup.Count() > 2orderby custGroup.Keyselect custGroup;

5.5 Combinacin

Las operaciones de combinacin crean asociaciones entre las secuencias que no se modelan explcitamente

en los orgenes de datos. Por ejemplo, puede realizar una combinacin para buscar todos los clientes y

distribuidores que tengan la misma ubicacin. En LINQ, la clusula join funciona siempre con colecciones de

objetos, en lugar de con tablas de base de datos directamente.




var innerJoinQuery =from cust in customersjoin dist in distributors on cust.City equals dist.Cityselect new { CustomerName = cust.Name, DistributorName = dist.Name };

En LINQ no es necesario utilizar join tan a menudo como en SQL, porque las claves externas en LINQ serepresentan en el modelo de objetos como propiedades que contienen una coleccin de elementos. Por

ejemplo, un objeto Customer contiene una coleccin de objetos Order. En lugar de realizar una combinacin,

se tiene acceso a los pedidos utilizando la notacin de punto:

5.6 Seleccin (proyecciones)

La clusula select genera resultados de consulta y especifica la "forma" o el tipo de cada elemento devuelto.Por ejemplo, puede especificar si sus resultados estarn compuestos de objetos Customer completos, un solo

miembro, un subconjunto de miembros o algn tipo de resultado completamente diferente basado en un

clculo o en un objeto nuevo. Cuando la clusula select genera algo distinto de una copia del elemento de

origen, la operacin se denomina proyeccin. El uso de proyecciones para transformar los datos es una

eficaz funcionalidad de las expresiones de consulta LINQ.

5.6.1 Seleccionar un subconjunto de cada elemento de origen

Principalmente existen dos maneras de seleccionar un subconjunto de cada elemento de la secuencia de

origen:

1. Para seleccionar un solo miembro del elemento de origen, utilice la operacin con punto. En el ejemplo

siguiente, supongamos que un objeto Customer contiene varias propiedades pblicas que incluyen una

cadena denominada City. Cuando se ejecuta, esta consulta generar una secuencia de salida de cadenas.

var query = from cust in Customersselect cust.City;

2. Para crear elementos que contienen ms de una propiedad del elemento de origen, puede utilizar uninicializador de objeto con un objeto con nombre o un tipo annimo. En el ejemplo siguiente se muestra el

uso de un tipo annimo para encapsular dos propiedades de cada elemento Customer:

var query = from cust in Customerselect new {Name = cust.Name, City = cust.City};

5.7 Realizar operaciones con elementos de origen




Es posible que una secuencia de salida no contenga elementos o propiedades de elemento de la secuencia

de origen. Por el contrario, la salida podra ser una secuencia de valores que se calcula utilizando los

elementos de origen como argumentos de entrada. Cuando se ejecuta la siguiente consulta simple, genera

una secuencia de cadenas cuyos valores representan un clculo basado en la secuencia de origen de

elementos de tipo double.

class FormatQuery{

static void Main(){

// Data source.double[] radii = { 1, 2, 3 };

// Query.IEnumerable query =

from rad in radiiselect String.Format("Area = {0}", (rad * rad) * 3.14);

// Query execution.foreach (string s in query)

Console.WriteLine(s);

// Keep the console open in debug mode.Console.WriteLine("Press any key to exit.");Console.ReadKey();

}}/* Output:

Area = 3.14Area = 12.56Area = 28.26

*/

6. SINTAXIS DE CONSULTAS LINQ Y SINTAXIS DE MTODOS (C#)

La mayora de las consultas en la documentacin de LINQ de introduccin se escriben como expresiones de

consulta utilizando la sintaxis de consulta declarativa introducida en C# 3.0. Sin embargo, Common Language

Runtime (CLR) de .NET no tiene el concepto de sintaxis de consulta en s. Por consiguiente, en tiempo de

compilacin, las expresiones de consulta se convierten en elementos que CLR reconoce, esto es, llamadas a

mtodo. Estos mtodos se conocen como operadores de consulta estndar y tienen nombres como Where,Select, GroupBy, Join, Max, Average, etc. Se pueden llamar directamente usando sintaxis de mtodo en

lugar de sintaxis de consulta.

Por lo general, recomendamos la sintaxis de consulta porque normalmente es ms fcil y legible; sin

embargo, no hay ninguna diferencia semntica entre la sintaxis de mtodo y la sintaxis de consulta. Adems,algunas consultas, como las que recuperan el nmero de elementos que coinciden con una condicin




especificada o las que recuperan el elemento que tiene el valor mximo de una secuencia de origen, slo se

pueden expresar como llamadas a mtodo. En la documentacin de referencia de los operadores de consulta

estndar en el espacio de nombres System.Linq generalmente se utiliza la sintaxis de mtodo. Por

consiguiente, aunque est empezando a escribir consultas LINQ, le resultar til estar familiarizado con el

uso de la sintaxis de mtodo en consultas y en expresiones de consulta.

6.1 Mtodos de extensin de operador de consulta estndar

En el ejemplo siguiente se muestra una expresin de consulta simple y la consulta semnticamenteequivalente, escrita como consulta basada en mtodo.

class QueryVMethodSyntax{

static void Main(){

int[] numbers = { 5, 10, 8, 3, 6, 12};

//Query syntax:IEnumerable numQuery1 =

from num in numberswhere num % 2 == 0orderby numselect num;

//Method syntax:IEnumerable numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n

=> n);

foreach (int i in numQuery1){

Console.Write(i + " ");}Console.WriteLine(System.Environment.NewLine);foreach (int i in numQuery2){

Console.Write(i + " ");}

// Keep the console open in debug mode.Console.WriteLine(System.Environment.NewLine);Console.WriteLine("Press any key to exit");Console.ReadKey();

}}/*

Output:6 8 10 126 8 10 12

*/

El resultado de los dos ejemplos es idntico. Puede ver que el tipo de la variable de consulta es el mismo en




ambos formatos: IEnumerable.

Para entender la consulta basada en mtodo, examinmosla ms de cerca. En el lado derecho de la

expresin, observe que la clusula where se expresa ahora como un mtodo de instancia en el objeto

numbers, que, como recordar, es de tipo IEnumerable.

Si est familiarizado con la interfaz genrica IEnumerable, sabr que no tiene un mtodo Where. Sin

embargo, si invoca la lista de finalizacin de IntelliSense en el IDE de Visual Studio, ver no slo un mtodo

Where, sino muchos otros mtodos, como Select, SelectMany, Join y Orderby. stos son todos los

operadores de consulta estndar.

Aunque parece que IEnumerable se ha redefinido para incluir estos mtodos adicionales, no es as. Los

operadores de consulta estndar se implementan como un nuevo tipo de mtodo denominado mtodo de

extensin. Los mtodos de extensin "extienden" un tipo existente; se pueden llamar como si fueran mtodos

de instancia en el tipo. Los operadores de consulta estndar extienden IEnumerable y por eso puede

escribir numbers.Where(...).

Para empezar a utilizar LINQ, todo lo que realmente tiene que saber sobre los mtodos de extensin es cmo

incluirlos en el mbito en su aplicacin utilizando las directivas using correctas. Esto se explica adems en

Desde el punto de vista de la aplicacin, un mtodo de extensin y un mtodo de instancia normal son

iguales.

Algunos proveedores LINQ, como LINQ to SQL y LINQ to XML, implementan sus propios operadores de

consulta estndar y mtodos de extensin adicionales para otros tipos adems de IEnumerable.

6.2 Expresiones lambda

En el ejemplo anterior, observe cmo la expresin condicional (num % 2 == 0) se pasa como argumento en

lnea al mtodo Where: Where(num => num % 2 == 0). Esta expresin insertada se denomina expresin




lambda. Es una manera sencilla de escribir cdigo que de lo contrario sera ms complejo y debera escribirse

como mtodo annimo, delegado genrico o rbol de expresin. En C#, => es el operador lambda, que se lee

como "va a". El elemento num que est a la izquierda del operador es la variable de entrada que corresponde

a num en la expresin de consulta. El compilador puede deducir el tipo de num porque sabe que numbers es

un tipo IEnumerable genrico. El cuerpo de una expresin lambda es exactamente igual que el de una

expresin en sintaxis de consulta o cualquier otra expresin o instruccin de C#; puede incluir llamadas a

mtodo y otra lgica compleja. El "valor devuelto" es tan solo el resultado de la expresin.

Para iniciarse en LINQ, no es necesario utilizar muchas expresiones lambda. Sin embargo, ciertas consultas

slo se pueden expresar en sintaxis de mtodo y algunas requieren el uso de expresiones lambda. Una vez

que est ms familiarizado con las expresiones lambda, ver que son una herramienta eficaz y flexible en su

cuadro de herramientas LINQ.

6.3 Combinabilidad de las consultas

En el ejemplo de cdigo anterior, observe que se invoca el mtodo OrderBy usando el operador de punto en

la llamada a Where. Where crea una secuencia filtrada y, a continuacin, Orderby acta en esa secuencia

ordenndola. Dado que las consultas devuelven IEnumerable, en la sintaxis de mtodo se combinan

concatenando las llamadas a mtodo. Esto es lo que el compilador hace en segundo plano cuando se

escriben consultas en sintaxis de consulta. Y, dado que una variable de consulta no almacena los resultados

de la consulta, puede modificarla o utilizarla en cualquier momento como base para una nueva consulta,

incluso despus de haberla ejecutado.

PROCEDIMENTO:

1. Select - Simple

Utiliza la sentencia select para producer una secuencias de nmeros enteros incrementando en 1 cada uno de loselementos del arreglo.

public void Linq6(){

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

var numsPlusOne =from n in numbersselect n + 1;




Console.WriteLine("Numbers + 1:");foreach (var i in numsPlusOne){

Console.WriteLine(i);}

}

Resultado

Numbers + 1:65241097831

2. Select - Transformation

Usa Select para producir una secuencia de cadenas de texto, mostrando las cadenas segn el orden de los nmerosenteros.


int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "s

even", "eight", "nine" };

var textNums =from n in numbersselect strings[n];

Console.WriteLine("Number strings:");foreach (var s in textNums){

Console.WriteLine(s);}

}

Resultado

Number strings:fivefouronethree




nineeightsixseventwozero

3. Select - Anonymous Types

El select produce una secuencia de cadenas de texto uppercase y lowercase por cada uno de los elementos delarreglo original.


string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };

var upperLowerWords =from w in wordsselect new { Upper = w.ToUpper(), Lower = w.ToLower() };

foreach (var ul in upperLowerWords){

Console.WriteLine("Uppercase: {0}, Lowercase: {1}", ul.Upper, ul.Lower);}

}

Resultado

Uppercase: APPLE, Lowercase: appleUppercase: BLUEBERRY, Lowercase: blueberryUppercase: CHERRY, Lowercase: cherry

4. Select - Anonymous Types

El select produce una secuencia de cadenas de texto representados por un dgitos que indica si es par o impar.


int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "s

even", "eight", "nine" };

var digitOddEvens =from n in numbersselect new { Digit = strings[n], Even = (n % 2 == 0) };




foreach (var d in digitOddEvens){

Console.WriteLine("The digit {0} is {1}.", d.Digit, d.Even ? "even" : "odd");

}}

Resultado

The digit five is odd.The digit four is even.The digit one is odd.The digit three is odd.The digit nine is odd.The digit eight is even.The digit six is even.The digit seven is odd.The digit two is even.The digit zero is even.

5. Select - Filtered

Combina el select y el where para hacer una consulta que retorne una lista de los nmeros menores a 5.


int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "se

ven", "eight", "nine" };

var lowNums =from n in numberswhere n < 5select digits[n];

Console.WriteLine("Numbers < 5:");foreach (var num in lowNums){

Console.WriteLine(num);}

}

Resultado

Numbers < 5:four




onethreetwozero

6. LINQ contra coleccin de objetos (LINQ to Objects)

La consulta siguiente devuelve los alumnos que obtuvieron una puntuacin de 90 o ms en su primerexamen.

public class StudentClass{

#region dataprotected enum GradeLevel { FirstYear = 1, SecondYear, ThirdYear, FourthYear

};protected class Student{

public string FirstName { get; set; }public string LastName { get; set; }public int ID { get; set; }public GradeLevel Year;public List ExamScores;

}

protected static List students = new List{

new Student {FirstName = "Terry", LastName = "Adams", ID = 120,Year = GradeLevel.SecondYear,ExamScores = new List{ 99, 82, 81, 79}},

new Student {FirstName = "Fadi", LastName = "Fakhouri", ID = 116,Year = GradeLevel.ThirdYear,ExamScores = new List{ 99, 86, 90, 94}},

new Student {FirstName = "Hanying", LastName = "Feng", ID = 117,Year = GradeLevel.FirstYear,ExamScores = new List{ 93, 92, 80, 87}},

new Student {FirstName = "Cesar", LastName = "Garcia", ID = 114,Year = GradeLevel.FourthYear,ExamScores = new List{ 97, 89, 85, 82}},

new Student {FirstName = "Debra", LastName = "Garcia", ID = 115,Year = GradeLevel.ThirdYear,ExamScores = new List{ 35, 72, 91, 70}},

new Student {FirstName = "Hugo", LastName = "Garcia", ID = 118,Year = GradeLevel.SecondYear,ExamScores = new List{ 92, 90, 83, 78}},

new Student {FirstName = "Sven", LastName = "Mortensen", ID = 113,Year = GradeLevel.FirstYear,ExamScores = new List{ 88, 94, 65, 91}},

new Student {FirstName = "Claire", LastName = "O'Donnell", ID = 112,Year = GradeLevel.FourthYear,ExamScores = new List{ 75, 84, 91, 39}},

new Student {FirstName = "Svetlana", LastName = "Omelchenko", ID = 111,Year = GradeLevel.SecondYear,ExamScores = new List{ 97, 92, 81, 60}},




new Student {FirstName = "Lance", LastName = "Tucker", ID = 119,Year = GradeLevel.ThirdYear,ExamScores = new List{ 68, 79, 88, 92}},

new Student {FirstName = "Michael", LastName = "Tucker", ID = 122,Year = GradeLevel.FirstYear,ExamScores = new List{ 94, 92, 91, 91}},

new Student {FirstName = "Eugene", LastName = "Zabokritski", ID = 121,Year = GradeLevel.FourthYear,ExamScores = new List{ 96, 85, 91, 60}}

};#endregion

//Helper method, used in GroupByRange.protected static int GetPercentile(Student s){

double avg = s.ExamScores.Average();return avg > 0 ? (int)avg / 10 : 0;

}

public void QueryHighScores(int exam, int score){

var highScores = from student in studentswhere student.ExamScores[exam] > scoreselect new {Name = student.FirstName, Score =

student.ExamScores[exam]};

foreach (var item in highScores){

Console.WriteLine("{0,-15}{1}", item.Name, item.Score);}

}}

public class Program{

public static void Main(){

StudentClass sc = new StudentClass();sc.QueryHighScores(1, 90);

// Keep the console window open in debug mode.Console.WriteLine("Press any key to exit");Console.ReadKey();

}}

7. LINQ contra coleccin de objetos (LINQ to Objects)

Esta estructura de datos completa se inicializar, y se crearn instancias de ella, sin llamadas explcitas a unconstructor o sin acceso a miembros explcito

Agregando el origen de datos




Agregue la clase Student y la lista inicializada de estudiantes a la clase Program de su proyecto.

public class Student{

public string First { get; set; }public string Last { get; set; }public int ID { get; set; }public List Scores;

}

// Create a data source by using a collection initializer.static List students = new List{

new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= newList {97, 92, 81, 60}},

new Student {First="Claire", Last="ODonnell", ID=112, Scores= new List{75, 84, 91, 39}},

new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List{88, 94, 65, 91}},

new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List {97,89, 85, 82}},

new Student {First="Debra", Last="Garcia", ID=115, Scores= new List {35,72, 91, 70}},

new Student {First="Fadi", Last="Fakhouri", ID=116, Scores= new List {99,86, 90, 94}},

new Student {First="Hanying", Last="Feng", ID=117, Scores= new List {93,92, 80, 87}},

new Student {First="Hugo", Last="Garcia", ID=118, Scores= new List {92,90, 83, 78}},

new Student {First="Lance", Last="Tucker", ID=119, Scores= new List {68,79, 88, 92}},

new Student {First="Terry", Last="Adams", ID=120, Scores= new List {99,82, 81, 79}},

new Student {First="Eugene", Last="Zabokritski", ID=121, Scores= new List{96, 85, 91, 60}},

new Student {First="Michael", Last="Tucker", ID=122, Scores= new List{94, 92, 91, 91} }};

Creando una consulta sencilla

En el mtodo Main de la aplicacin, cree una consulta simple que, cuando se ejecute, genere una lista detodos los estudiantes cuya puntuacin fue mayor que 90 en el primer examen. Tenga en cuenta que, comose selecciona el objeto Student, el tipo de la consulta es IEnumerable.

Aunque en el cdigo tambin se podra utilizar un tipo implcito mediante la palabra clave var, se usa un tipoexplcito para ilustrar los resultados de forma ms clara.

Observe tambin que la variable de rango de la consulta, student, sirve de referencia para cada Student delorigen, proporcionando acceso a los miembros de cada objeto.




// Create the query.// The first line could also be written as "var studentQuery ="IEnumerable studentQuery =

from student in studentswhere student.Scores[0] > 90select student;

Para ejecutar la consulta

1. Ahora escriba el bucle foreach que har que se ejecute la consulta. Tenga en cuenta lo siguiente acercadel cdigo:

o Se tiene acceso a cada elemento de la secuencia devuelta a travs de la variable de iteracin delbucle foreach.

o El tipo de esta variable es Student, y el tipo de la variable de consulta es compatible,IEnumerable.

2. Despus de haber agregado este cdigo, compile y ejecute la aplicacin; para ello, presione Ctrl + F5. Losresultados aparecern en la ventana Consola.

// Execute the query.// var could be used here also.foreach (Student student in studentQuery){

Console.WriteLine("{0}, {1}", student.Last, student.First);}

Para agregar otra condicin de filtro

Puede combinar varias condiciones booleanas en la clusula where para delimitar ms la consulta. El cdigosiguiente agrega una condicin para que la consulta devuelva los estudiantes cuya primera puntuacin fuesuperior a 90 y cuya ltima puntuacin fue inferior a 80. La clusula where se debera parecer a la del cdigosiguiente.

where student.Scores[0] > 90 && student.Scores[3] < 80

Para ordenar los resultados

1. Ser ms fcil examinar los resultados si estn ordenados de alguna manera. Puede ordenar la secuenciadevuelta segn cualquier campo accesible de los elementos de origen. Por ejemplo, la clusula orderbysiguiente ordena los resultados alfabticamente, de la A a la Z, por apellido de estudiante. Agregue lasiguiente clusula orderby a la consulta, justo detrs de la instruccin where y delante de la instruccinselect:

orderby student.Last ascending

2. Ahora cambie la clusula orderby de forma que ordene los resultados en orden inverso, segn lapuntuacin del primer examen, de mayor a menor.

orderby student.Scores[0] descending




3. Cambie la cadena de formato WriteLine para poder ver las puntuaciones:

Console.WriteLine("{0}, {1} {2}", student.Last, student.First,student.Scores[0]);

8. LINQ contra XML (LINQ to XML)

Veamos mediante un ejemplo prctico y sencillo como leer desde el disco un archivo XML con .NET (C#).

En el .NET 3.5 se han agregado 3 nuevas clases (XDocument, XElement, XAttribute) relacionadas alespacio de nombre (namespace) System.Xml.Linq; con estas clases de .NET es muy simple leer un ficheroXML, veamos un ejemplo de como hacerlo, para ello usaremos C#.

Pero antes veamos el fichero XML que pretendemos leer.

Archivo XML a LeerCreamos el fichero XML Contactos.xml con el siguiente contenido:

[email protected]

[email protected]

[email protected]

Nota: Debemos tomar en cuenta el nombre del archivo y la ruta donde se graba al momento de leerlo.

Cdigo LINQ XML para leer Archivo

Existen varias formas en .NET C# para leer un fichero XML, ac expondremos 2 formas distintas aunque sifuera yo quien tuviese que elegir me quedara con esta primera variante de cdigo para leer un archivo XML.Esta primera variante usa el mtodo Descendants que existe en ambas clases (XElement y XDocument):

// Cdigo para leer un fichero XML usando LINQ 2 XML




private static void Linq2XmlLeerFicheroXmlConXElement(){

XElement xmlContactos = XElement.Load("Contactos.xml");

//Obtener el Nombre de todos los contactosvar contactosAll =

from c in xmlContactos.Descendants("Contacto")select c.Element("Nombre").Value;

//Obtener todos los contactos cuyo nombre comiencen con Lvar contactosL =

from c in xmlContactos.Descendants("Contacto")where c.Element("Nombre").Value.StartsWith("L")select c;

//Obtener todos los contactos que al menos uno de los Telefonos sea de Tipo Personalvar contactosTelPers =

from c in xmlContactos.Descendants("Contacto")where null != c.Elements("Telefono").Attributes("Tipo").

FirstOrDefault(t => t.Value == "Personal")select c;

}

Otra variante de cdigo para obtener el mismo resultado:

// Cdigo para leer un fichero XML usando LINQ 2 XMLprivate static void Linq2XmlLeerFicheroXml(){

XDocument docContactos = XDocument.Load("Contactos.xml");

//Obtener el Nombre de todos los contactosvar contactosAll =

from c in docContactos.Elements("Contactos").Elements("Contacto")select c.Element("Nombre").Value;

//Obtener todos los contactos cuyo nombre comiencen con Lvar contactosL =

from c in docContactos.Elements("Contactos").Elements("Contacto")where c.Element("Nombre").Value.StartsWith("L")select c;

//Obtener todos los contactos que al menos uno de los Telefonos sea de Tipo Personalvar contactosTelPers =

from c in docContactos.Elements("Contactos").Elements("Contacto")where null != c.Elements("Telefono").Attributes("Tipo").

FirstOrDefault(t => t.Value == "Personal")select c;

}

Con este ejemplo lo que logramos es leer el fichero XML Contactos.xml y realizar diferentes consultas LINQfiltrando por determinados criterios.

Firma del Docente


Download - LABO03 - LINQ DRAI

Top Related