PDF de programación - Operadores de LINQ

Operadores de LINQ






Jesús Rodríguez Rodríguez

 

2



Operadores de LINQ


Primera Edición, Mayo de 2010
http://www.foxandxss.net

Libro publicado bajo la licencia Creative Commons











 

3 Operadores de LINQ



OPERADORES DE LINQ

1. FILTERING (FILTRADO)

1.1 OFTYPE
1.2 WHERE

2. PROJECTION (PROYECCIÓN)

2.1 SELECT

3. PARTITIONING (PARTICIONADO)

3.1 SKIP
3.2 SKIPWHILE
3.4 TAKEWHILE

4. JOIN (UNIÓN)

4.1 GROUPJOIN

5. CONCATENATION (CONCATENACIÓN)

5.1 CONCAT

6. ORDERING (ORDENACIÓN)

6.1 ORDERBY
6.2 ORDERBYDESCENDING
6.3 REVERSE
6.4 THENBY
6.5 THENBYDESCENDING

7. GROUPING (AGRUPACIÓN)




1 

6 

6 
7 

9 

9 

17 

17 
18 
21 

23 

23 

32 

32 

33 

33 
35 
38 
39 
42 

45 



7.1 GROUPBY
7.2 TOLOOKUP

8. SET (CONJUNTO)

8.1 DISTINCT

8. SET (CONJUNTO)

8.3 INTERSECT
8.4 UNION

9. CONVERSION (CONVERSIÓN)

9.1 ASENUMERABLE
9.2 ASQUERYABLE
9.3 CAST
9.4 TOARRAY
9.5 TODICTIONARY
9.6 TOLIST

10. EQUALITY (IGUALDAD)

10.1 SEQUENCEEQUAL

11. ELEMENT (ELEMENTO)

11.1 ELEMENTAT
11.2 ELEMENTATORDEFAULT
11.3 FIRST
11.4 FIRSTORDEFAULT
11.5 LAST
11.6 LASTORDEFAULT
11.7 SINGLE
11.8 SINGLEORDEFAULT




Operadores de LINQ

4

45 
55 

60 

60 

62 

64 
67 

70 

70 
71 
72 
73 
74 
78 

80 

80 

82 

82 
82 
83 
84 
85 
87 
88 
89 

91 

91 
92 
93 
94 

95 

95 
96 
97 

100 

100 
102 
104 
105 
106 
108 
109 

5 Operadores de LINQ



12. GENERATION (GENERACIÓN)

12.1 DEFAULTIFEMPTY
12.2 EMPTY
12.3 RANGE
12.4 REPEAT

13. QUANTIFIER (CUANTIFICADORES)

13.1 ALL
13.2 ANY
13.3 CONTAINS

14. AGGREGATION (AGREGACIÓN)

14.1 AGGREGATE
14.2 AVERAGE
14.3 COUNT
14.4 LONGCOUNT
14.5 MAX
14.6 MIN
14.7 SUM







1. Filtering (Filtrado)

6


1. Filtering (Filtrado)


1.1 OfType

El operador OfType nos permite filtrar una secuencia dado un tipo.

1.1.1 Código necesario para los ejemplos

Lista de objetos al azar:

object[] objetos = { "LINQ", 1, 23.4F, "Perro",


new object(), "Casa" };



















1.1.2 OfType

public static IEnumerable<TResult> OfType<TResult>(
this IEnumerable source
)



Le especificamos el tipo que queremos filtrar y nos devuelve una
enumeración de dicho tipo.

Por ejemplo, si queremos solo los elementos del tipo string usamos el
operador OfType para filtrar esa secuencia:

IEnumerable<string> cadenas = objetos.OfType<string>();



Si imprimimos el resultado, la salida sería:

LINQ

Perro
Casa




7 Operadores de LINQ



1.2 Where

El operador Where nos permite filtrar una secuencia, pero a diferencia
de OfType, el operador Where es mucho más flexible puesto que admite
como parámetro un delegado.

1.2.1 Código necesario para los ejemplos

Lista de títulos (imaginarios) de libros:

var libros = new List<string>








"Programando en C#",
"LINQ para torpes",
"WPF para todos",
"Empezando con LINQ",
"LINQ Avanzado"









{





};



1.2.2 Where estándar

public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, bool> predicate
)



En este caso Where acepta un delegado el cual recibe como parámetro
un elemento de la secuencia y nos devuelve un bool que nos indica si ese
elemento se filtra o no. El operador devuelve una enumeración con los
elementos filtrados.

Queremos una nueva lista de libros donde sólo estén los que sean de
LINQ, para ello usamos Where.

IEnumerable<string> librosLINQ = libros.Where(

libro => libro.Contains("LINQ"));



Además, el operador Where se puede convertir a la sintaxis de un query
expression:

IEnumerable<string> librosLINQ = from libro in libros

where libro.Contains("LINQ")
select libro;












En ambos casos, el resultado de imprimirlo sería:

1. Filtering (Filtrado)

8

LINQ para torpes

Empezando con LINQ

LINQ Avanzado



1.2.3 Where + índice

public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, int, bool> predicate
)



En este caso, el delegado acepta también un int el cual representa la
posición de cada elemento en la secuencia que estamos filtrando.

Así que si por ejemplo queremos aquellos libros de LINQ que estén
dentro de las 3 primeras posiciones de la secuencia, podemos usar el
siguiente fragmento:

IEnumerable<string> librosLINQ = libros.Where((libro, index) =>

libro.Contains("LINQ") && index < 3);



Esto imprimiría:

LINQ para Torpes



La versión de Where que acepta también el índice, no puede ser
convertida a la sintaxis de los query expressions.










9 Operadores de LINQ


2. Projection (Proyección)


2.1 Select

El operador Select nos permite proyectar cada elemento de una
secuencia a una nueva enumeración.

2.1.1 Código necesario para los ejemplos

Una pequeña clase representando una persona con una lista de gadgets:

public class Persona
{
public string Nombre { get; set; }
public int Edad { get; set; }
public List<string> Gadgets { get; set; }

public Persona(string nombre, int edad, List<string> gadgets)
{
Nombre = nombre;
Edad = edad;
Gadgets = gadgets;
}
}


Y una lista de dichas personas:

List<Persona> personas =
new List<Persona>
{
new Persona("Jesus",
24,
new List<string> {"Ipod", "HTC Diamond"}
),
new Persona("Juan",
20,
new List<string> {"Vaio", "Android"}
),
new Persona("Alvaro",
24,
new List<string> {"Pentium",

"Movil Ladrillo"}

)
};











2.1.2 Select estándar

2. Projection (Proyección)

10

public static IEnumerable<TResult> SelectMany<TSource, TResult>(
this IEnumerable<TSource> source,
Func<TSource, IEnumerable<TResult>> selector
)


El argumento es un delegado que acepta un elemento de la secuencia y
devuelve el elemento que queramos proyectar. El operador devuelve una
enumeración de aquellos elementos que hemos proyectado.

Queremos una lista solo con los nombres de las personas, para ello
hemos de proyectar los nombres de cada persona en una nueva
enumeración:

IEnumerable<string> nombres = personas.Select(

persona => persona.Nombre);



Podemos convertir el operador Select a la sintaxis de un query
expression:

IEnumerable<string> nombres = from persona in personas
select persona.Nombre;


En ambos casos el resultado de imprimir la secuencia sería:

Juan

Alvaro



Además podemos crear tipos anónimos proyectando solo las partes que
queramos de una clase, por ejemplo, si solo queremos el nombre y la
edad:

var nombreYEdad = from persona in personas
select new { persona.Nombre, persona.Edad };


Esto crearía un tipo anónimo y dentro sería algo así:

Nombre=Jesus Edad=24

Nombre=Juan Edad=20
Nombre=Alvaro Edad=25









11 Operadores de LINQ



Por otro lado, si quisiéramos imprimir la lista de gadgets, haríamos algo
así:

<List<string>> ListasGadgets = from persona in personas
select persona.Gadgets;


Esa proyección devuelve una enumeración de listas, así que tendríamos
que hacer dos iteraciones para mostrar los gadgets:

foreach (var lista in ListasGadgets)
foreach (var gadget in lista)
Console.WriteLine(gadget);


La salida como cabe de esperar es:

Ipod

HTC Diamond

Vaio

Android

Pentium
Movil Ladrillo





Podemos ver una versión mejorada de este último ejemplo usando
SelectMany.

2.1.3 Select + Índice

public static IEnumerable<TResult> Select<TSource, TResult>(
this IEnumerable<TSource> source,
Func<TSource, int, TResult> selector
)


El delegado recibe el elemento en cuestión, además del índice de la
posición del elemento en la secuencia.

Vamos a suponer que queremos crear un tipo anónimo con cada índice y
nombre:

var nombres = personas.Select((persona, indice) =>
new { persona.Nombre, indice });









2. Projection (Proyección)

12



El resultado es:

Nombre=Jesus indice=0

Nombre=Juan indice=1

Nombre=Alvaro indice=2



Esta sobrecarga del operador Select no admite su forma en query
expression.


2.2 SelectMany

El operador SelectMany es similar al operador Select a excepción de
que SelectMany coge cada elemento que proyecta, lo convierte en una
enumeración, y luego concatena todas las enumeraciones.

2.2.1 Código necesario para los ejemplos

Una clase representando una persona y una lista de gadgets:

public class Persona
{
public string Nombre { get; set; }
public int Edad { get; set; }
public List<string> Gadgets { get; set; }

public Persona(string nombre, int edad, List<string> gadgets)
{
Nombre = nombre;
Edad = edad;
Gadgets = gadgets;
}
}


Y una lista de dichas personas:

List<Persona> personas =
new List<Persona>
{
new Persona("Jesus",
24,
new List<string> {"Ipod", "HTC Diamond"}
),
new Persona("Juan",
20,
new List<string> {"Vaio", "Android"}
),




13 Operadores de LINQ



new Persona("Alvaro",
24,