Hoy en día, las tecnologías de programación orientada a objetos se han convertido en una de las formas más comunes de programar en el desarrollo de proyectos de software. Ahora los programadores están familiarizados con conceptos tales como clases, objetos y métodos.

El siguiente gran reto consiste en integrar la información no definida de forma nativa y reducir la complejidad del acceso a la misma, utilizando la tecnología orientada a objetos. Las dos fuentes de información no orientadas a objetos más conocidas son las bases de datos relacionales y XML.

Es en este contexto donde un proyecto como LINQ (Lenguage Integrated Query) adquiere mayor relevancia al aportar un enfoque más general, añadiendo a .NET Framework facilidades de consulta de propósito general aplicables a todas las fuentes de información, y no solo a los datos relacionales o XML.

Escrito para desarrolladores C# y VB de todos los niveles, este libro resulta esencial para dominar la tecnología Microsoft .NET LINQ y el conjunto de herramientas que lo acompaña.

Explorará las características clave del lenguaje como expresiones lambda, métodos de extensión y tipos de datos anónimos que hacen posible LINQ. Dominará los operadores estándar de consulta y conocerá las principales técnicas para consultar objetos, bases de datos relacionales y XML.

Ahorra Con Agapea
"Compra "LINQ" junto a "Hipatia de Alejandría":

Por solo 62.8 € Gastos de envío gratis^**

Prólogos
Introducción
Quién debería leer este libro
Cómo se organiza el libro
Herramientas utilizadas
Convenciones
Código fuente
Sobre la ilustración de la portada

Parte I. Para comenzar

1. Presentación de LINQ
1.1. ¿Qué es LINQ?
1.1.1. Visión general
1.1.2. LINQ como un conjunto de herramientas
1.1.3. LINQ como extensiones de lenguaje
1.2. ¿Por qué necesitamos LINQ?
1.2.1. Problemas comunes
1.2.2. Abordar un desajuste de paradigma
¿Qué es este desajuste de impedancia del que todo el mundo habla?
Mapeado relacional de objetos
Mapeado XML de objeto
1.2.3. LINQ al rescate
1.3. Objetivos de diseño y orígenes de LINQ
1.3.1. Los objetivos del proyecto LINQ
1.3.2. Un poco de historia
C? (o el lenguaje C-Omega)
ObjectSpaces
Implementación XQuery
1.4. Primeros pasos con LINQ to Objects: hacer consultas sobre colecciones en memoria
1.4.1. Qué necesita para empezar
Compilador y soporte .NET Framework y software requerido
Consideraciones de lenguaje
1.4.2. Hola LINQ to Objects
1.5. Primeros pasos con LINQ to XML: hacer consultas sobre documentos XML
1.5.1. Por qué necesitamos LINQ to XML
1.5.2. Hola LINQ to XML
1.6. Primeros pasos con LINQ to SQL: consultar bases de datos relacionales
1.6.1. Visión general de las características LINQ to SQL
1.6.2. Hello LINQ to SQL
Clases de entidad
El DataContext
1.6.3. Examinar más detalladamente LINQ to SQL
1.7. Resumen
2. Mejoras en el lenguaje C# y VB.NET
2.1. Descubrir las nuevas mejoras del lenguaje
2.1.1. Generar un listado de procesos en curso
2.1.2. Agrupar resultados en una clase
2.2. Variables locales implícitamente tipadas
2.2.1. Sintaxis
2.2.2. Mejorar nuestro ejemplo utilizando variables locales implícitamente tipadas
2.3. Inicializadores de objeto y colección
2.3.1. La necesidad de inicializadores de objeto
2.3.2. Inicializadores de colección
2.3.3. Mejorar nuestro ejemplo utilizando un inicializador de objeto
2.4. Expresiones lambda
2.4.1. Un repaso de los delegados
2.4.2. Métodos anónimos
2.4.3. Presentar las expresiones lambda
Comparar expresiones lambda con métodos anónimos
Cómo expresar expresiones lambda
2.5. Métodos de extensión
2.5.1. Crear un método de extensión de ejemplo
Declarar métodos de extensión en C#
Declarar métodos de extensión en VB.NET
2.5.2. Más ejemplos utilizando operadores estándar de consulta de LINQ
OrderByDescending
Take
Sum
2.5.3. Métodos de extensión en acción en nuestro ejemplo
2.5.4. Advertencias
2.6. Tipos anónimos
2.6.1. Utilizar tipos anónimos para agrupar datos en un objeto
2.6.2. Tipos sin nombres, pero tipos, no obstante
2.6.3. Mejorar nuestro ejemplo utilizando tipos anónimos
2.6.4. Limitaciones
Tipos anónimos con claves
2.7. Resumen
3. Bloques de construcción LINQ
3.1. Cómo LINQ amplía .NET
3.1.1. Repaso de las extensiones de lenguaje
3.1.2. Los elementos clave de los fundamentos LINQ
3.2. Presentar las secuencias
3.2.1. IEnumerable
3.2.2. Resumen sobre iteradores
3.2.3. Ejecución diferida de consulta
Demostrar ejecución diferida de consulta
Reutilizar una consulta para obtener resultados diferentes
Forzar ejecución inmediata de consulta
3.3. Presentar los operadores de consulta
3.3.1. ¿Qué es un operador de consulta?
3.3.2. Los operadores de consulta estándar
3.4. Presentar las expresiones de consulta
3.4.1. ¿Qué es una expresión de consulta?
3.4.2. Escribir expresiones de consulta
Sintaxis C#
Sintaxis VB.NET
3.4.3. Cómo se relacionan los operadores de consulta estándar con expresiones de consulta
3.4.4. Limitaciones
3.5. Presentar los árboles de expresión
3.5.1. Valor de retorno de las expresiones lambda
3.5.2. ¿Qué son los árboles de expresión?
3.5.3. IQueryable, ejecución de consulta diferida de nuevo
3.6. Las DLL y espacios de nombre LINQ
3.7. Resumen

Parte II. Consultar objetos en memoria

4. Familiarizarse con LINQ to Objects
4.1. Presentar nuestro ejemplo
4.1.1. Objetivos
4.1.2. Características
4.1.3. Las entidades de negocio
4.1.4. Esquema de base de datos
4.1.5. Datos de ejemplo
4.2. Utilizar LINQ con colecciones en memoria
4.2.1. ¿Qué podemos consultar?
Tablas
Listas genéricas
Diccionarios genéricos
Cadena
Otras colecciones
4.2.2. Operaciones soportadas
4.3. Utilizar LINQ con ASP.NET y Windows Forms
4.3.1. Vinculación de datos para aplicaciones Web
Paso 0: Crear un sitio Web ASP.NET
Paso 1: Crear nuestra primera página ASP.NET utilizando LINQ
Paso 2: Utilizar colecciones enriquecidas
4.3.2. Vincular datos para aplicaciones Windows Forms
Paso 0: Crear una aplicación Windows Forms
Paso 1: Crear nuestro primer formulario utilizando LINQ
Paso 2: Utilizar colecciones más ricas
4.4. Centrarse en los principales operadores de consulta estándar
4.4.1. Where, el operador de restricción
4.4.2. Utilizar operadores de proyección
Select
SelectMany
Seleccionar índices
4.4.3. Utilizar Distinct
4.4.4. Utilizar operadores de conversión
4.4.5. Utilizar operadores de acumulación (agregados)
4.5. Crear vistas en un gráfico de objeto en memoria
4.5.1. Ordenar
4.5.2. Consultas anidadas
4.5.3. Agrupar
4.5.4. Utilizar encuentros
Encuentro agrupado
Encuentro interno
Encuentros externos por la izquierda
Encuentros cruzados
4.5.5. Partición
Añadir paginación
Skip y Take
4.6. Resumen
5. Más allá de las consultas básicas en memoria
5.1. Escenarios comunes
5.1.1. Consultar colecciones no genéricas
5.1.2. Agrupar por múltiples criterios
5.1.3. Consultas dinámicas
Consulta parametrizada
Ordenación personalizada
Crear consultas condicionales
Crear consultas en tiempo de ejecución
5.1.4. LINQ to Text Files
5.2. Patrones de diseño
5.2.1. El patrón construcción funcional
5.2.2. El patrón ForEach
5.3. Consideraciones de rendimiento
5.3.1. Favorecer un enfoque streaming
5.3.2. Tenga cuidado con la ejecución inmediata
5.3.3. ¿Dañará LINQ to Objects el rendimiento de mi código?
Opciones
Lecciones aprendidas
5.3.4. Hacerse una idea sobre la sobrecarga de LINQ to Objects
5.3.5. Rendimiento frente a concisión: ¿un dilema cruel?
5.4. Resumen

Parte III. Consultar datos relacionales

6. Comenzar con LINQ to SQL
6.1. Saltar a LINQ to SQL
6.1.1. Configurar el mapeado de objeto
6.1.2. Configurar el DataContext
6.2. Leer datos con LINQ to SQL
6.3. Mejorar nuestras consultas
6.3.1. Filtrar
6.3.2. Ordenar y agrupar
6.3.3. Acumulación
6.3.4. Encuentros
6.4. Trabajar con árboles de objeto
6.5. ¿Cuándo se cargan mis datos y por qué importa?
6.5.1. Carga perezosa
6.5.2. Cargar detalles inmediatamente
6.6. Actualizar datos
6.7. Resumen
7. Un vistazo a LINQ to SQL
7.1. Mapear objetos a datos relacionales
7.1.1. Utilizar atributos en línea
Atributo Table
Atributo Column
Atributo Association
7.1.2. Mapear con archivos XML externos
7.1.3. Utilizar la herramienta SqlMetal
7.1.4. El diseñador de LINQ to SQL
7.2. Trasladar expresiones de consulta a SQL
7.2.1. IQueryable
7.2.2. Árboles de expresión
7.3. La entidad ciclo de vida
7.3.1. Registrar cambios
7.3.2. Enviar cambios
7.3.3. Trabajar con datos desconectados
7.4. Resumen
8. Características avanzadas LINQ to SQL
8.1. Gestionar cambios simultáneos
8.1.1. Concurrencia pesimista
8.1.2. Concurrencia optimista
8.1.3. Gestionar las excepciones de concurrencia
8.1.4. Resolver conflictos utilizando transacciones
8.2. Posibilidades de uso avanzadas de base de datos
8.2.1. SQL pass-through: devolver objetos de consultas SQL
8.2.2. Trabajar con procedimientos almacenados
Leer datos con procedimientos almacenados
Actualizar datos con procedimientos almacenados
8.2.3. Funciones definidas por el usuario
8.3. Mejorar la capa de negocio
8.3.1. Consultas compiladas
8.3.2. Clases parciales para lógica de negocio personalizada
8.3.3. Beneficiarse de los métodos parciales
8.3.4. Utilizar herencia de objeto
8.4. Un breve desvío a LINQ to Entities
8.5. Resumen

Parte IV. Manipular XML
9. Presentar LINQ to XML
9.1. ¿Qué es una API XML?
9.2. ¿Por qué necesitamos otra API de programación XML?
9.3. Principios de diseño LINQ to XML
9.3.1. Concepto clave: construcción funcional
9.3.2. Concepto clave: creación XML libre de contexto
9.3.3. Concepto clave: nombres simplificados
9.4. Jerarquía de clase LINQ to XML
9.5. Trabajar con XML utilizando LINQ
9.5.1. Cargar XML
9.5.2. Analizar XML
9.5.3. Crear XML
9.5.4. Crear XML con literales XML de Visual Basic
9.5.5. Crear documentos XML
XDeclaration
XProcessingInstruction
XDocumentType
XComment
9.5.6. Añadir contenido a XML
9.5.7. Eliminar contenido de XML
9.5.8. Actualizar contenido XML
9.5.9. Trabajar con atributos
9.5.10. Guardar XML
9.6. Resumen
10. Consultar y transformar XML con LINQ to XML
10.1. Métodos de eje LINQ to XML
10.1.1. Element
10.1.2. Attribute
10.1.3. Elements
10.1.4. Descendants
10.1.5. Ancestors
10.1.6. ElementsAfterSelf, NodesAfterSelf, ElementsBeforeSelf y NodesBeforeSelf
10.1.7. Propiedades de eje XML de Visual Basic
Propiedad de eje hijo
Propiedad de eje descendientes
Indexador de extensión y extensión Value
Propiedad de eje atributo
10.2. Operadores estándar de consulta
10.2.1. Proyectar con Select
10.2.2. Filtrar con Where
10.2.3. Ordenar y agrupar
10.3. Consultar objetos LINQ to XML con XPath
10.4. Transformar XML
10.4.1. Transformaciones LINQ to XML
10.4.2. Transformar objetos LINQ to XML con XSLT
10.5. Resumen
11. Escenarios comunes LINQ to XML
11.1. Crear objetos desde XML
11.1.1. Objetivo
11.1.2. Implementación
11.2. Crear XML desde gráficos de objeto
11.2.1. Objetivo
11.2.2. Implementación
11.3. Crear XML con datos de una base de datos
11.3.1. Objetivo
11.3.2. Implementación
11.4. Filtrar y mezclar datos de una base de datos con datos XML
11.4.1. Objetivo
11.4.2. Implementación
11.5. Leer XML y actualizar una base de datos
11.5.1. Objetivo
11.5.2. Implementación
11.6. Transformar archivos de texto en XML
11.6.1. Objetivo
11.6.2. Implementación
11.7. Resumen

Parte V. Poner todo junto
12. Ampliar LINQ
12.1. Descubrir los mecanismos de extensión de LINQ
12.1.1. Cómo los tipos LINQ son implementaciones LINQ
LINQ to Objects
LINQ to DataSet
LINQ to XML
LINQ to SQL
LINQ to Entities
12.1.2. Qué se puede hacer con las extensiones personalizadas LINQ
Casos de uso sugeridos para la ampliabilidad de LINQ
12.2. Crear operadores personalizados de consulta
12.2.1. Mejorar los operadores estándar de consulta
12.2.2. Operadores de consulta de utilidad o específicos de dominio
IEnumerable.TotalPrice
IEnumerable.Min
Publisher.Books
Book.IsExpensive
12.3. Implementaciones personalizadas de los operadores básicos de consulta
12.3.1. Refrescar el mecanismo de traducción de consulta
12.3.2. Especificación del patrón de expresión de consulta
12.3.3. Ejemplo 1: Mantener registro de ejecución de operadores estándar de consulta
12.3.4. Limitación: colisión de expresión de consulta
12.3.5. Ejemplo 2: Operadores no genérico específicos de dominio
12.3.6. Ejemplo 3: Operador de no secuencia
12.4. Consultar un servicio Web: LINQ to Amazon
12.4.1. Presentar LINQ to Amazon
12.4.2. Requerimientos
12.4.3. Implementación
12.5. IQueryable e IQueryProvider: Edición avanzada de LINQ to Amazon
12.5.1. Las interfaces IQueryable e IQueryProvider
Prepararse para la implementación
Visión general de IQueryable e IQueryProvider
12.5.2. Implementación
12.5.3. Qué sucede exactamente
12.6. Resumen
13. LINQ en cada capa
13.1. Visión general de la aplicación LinqBooks
13.1.1. Características
13.1.2. Visión general de la interfaz de usuario
13.1.3. El modelo de datos
13.2. LINQ to SQL y la capa de acceso a datos
13.2.1. Repaso de la arquitectura tradicional de tres capas
13.2.2. ¿Necesitamos una capa de acceso a datos aparte o es suficiente con LINQ to SQL?
Utilizar LINQ to SQL como su capa de acceso a datos
Utilizar LINQ to SQL para crear una capa de acceso a datos real
13.2.3. Usos de ejemplo de LINQ to SQL en LinqBooks
Resumen de las opciones
Código de ejemplo
13.3. Uso de LINQ to XML
13.3.1. Importar datos de Amazon
13.3.2. Generar RSS feeds
13.4. Uso de LINQ to DataSet
13.5. Utilizar LINQ to Objects
13.6. Ampliabilidad
13.6.1. Operadores personalizados de consulta
13.6.2. Crear y utilizar un proveedor personalizado LINQ
13.7. Una mirada hacia el futuro
13.7.1. Tipos personalizados LINQ
13.7.2. LINQ to XSD, el LINQ to XML tipado
13.7.3. PLINQ: LINQ conoce la computación paralela
13.7.4. LINQ to Entities, una interfaz LINQ para el ADO.NET Entity Framework
13.8. Resumen

Apéndice A. Los operadores estándar de consulta
Filtrado
Proyección
Partición
Encuentro
Concatenación
Ordenación
Agrupación
Conjuntos
Conversión
Igualdad
Elemento
Generación
Cuantificadores
Acumulación

Apéndice B. Recursos
Recursos LINQ in Action
Recursos Microsoft
Recursos de comunidad
Blogs
Otro

Índice alfabético