LINQ - Guía Rápida - Tutorial

8/11/2019 LINQ - Guía rápida - Tutorialspoint
LINQ - Guía rápida
LINQ - Descripción general
Los desarrolladores de todo el mundo siempre han tenido problemas para consultar datos debido a la
falta de una ruta definida y necesitan dominar múltiples tecnologías como SQL, Servicios web, XQuery,
etc.
Introducido en Visual Studio 2008 y diseñado por Anders Hejlsberg, LINQ (Language Integrated Query)
permite escribir consultas incluso sin el conocimiento de lenguajes de consulta como SQL, XML, etc. Las
consultas LINQ se pueden escribir para diversos tipos de datos.
Ejemplo de una consulta LINQ
C#
using System;
using System.Linq;
class Program {
static void Main() {
string[] words = {"hello", "wonderful", "LINQ", "beautiful", "world"};
//Get only short words

var shortWords = from word in words where word.Length <= 5 select word;
//Print each word out

foreach (var word in shortWords) {
Console.WriteLine(word);
}
Console.ReadLine();
}
}
VB
Module Module1
Sub Main()
Dim words As String() = {"hello", "wonderful", "LINQ", "beautiful", "world"}
' Get only short words
https://www.tutorialspoint.com/linq/linq_quick_guide.htm 1/63
Dim shortWords = From word In words _ Where word.Length <= 5 _ Select word
' Print each word out.
For Each word In shortWords

Console.WriteLine(word)
Next
Console.ReadLine()
End Sub
End Module
Cuando el código anterior de C # o VB se compila y ejecuta, produce el siguiente resultado:
hello
LINQ
world
Sintaxis de LINQ
Hay dos sintaxis de LINQ. Estos son los siguientes.
Sintaxis de Lamda (Método)
var longWords = words.Where( w ⇒ w.length > 10);

Dim longWords = words.Where(Function(w) w.length > 10)
Sintaxis de consulta (comprensión)
var longwords = from w in words where w.length > 10;

Dim longwords = from w in words where w.length > 10
Tipos de LINQ
Los tipos de LINQ se mencionan a continuación en breve.

LINQ to Objects
LINQ to XML (XLINQ)
LINQ to DataSet
LINQ to SQL (DLINQ)
LINQ to Entities
Además de lo anterior, también hay un tipo LINQ llamado PLINQ que es el LINQ paralelo de Microsoft.
Arquitectura LINQ en .NET
LINQ tiene una arquitectura de 3 capas en la que la capa superior consta de las extensiones de lenguaje
y la capa inferior consta de fuentes de datos que normalmente son objetos que implementan interfaces
genéricas IEnumerable <T> o IQueryable <T>. La arquitectura se muestra a continuación.
Consultar expresiones
La expresión de consulta no es más que una consulta LINQ, expresada en una forma similar a la de SQL
con operadores de consulta como Select, Where y OrderBy. Las expresiones de consulta generalmente
comienzan con la palabra clave "De".
Para acceder a los operadores de consulta LINQ estándar, el espacio de nombres System.Query debe
importarse de forma predeterminada. Estas expresiones se escriben dentro de una sintaxis de consulta
declarativa que era C # 3.0.
A continuación se muestra un ejemplo para mostrar una operación de consulta completa que consiste en
la creación de fuente de datos, definición de expresión de consulta y ejecución de consulta.
C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Operators {
class LINQQueryExpressions {
// Specify the data source.

int[] scores = new int[] { 97, 92, 81, 60 };
// Define the query expression.

IEnumerable<int> scoreQuery = from score in scores where score > 80 select score;
// Execute the query.
foreach (int i in scoreQuery) {

Console.Write(i + " ");
}
Console.ReadLine();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
97 92 81
Métodos de extensión
Introducido con .NET 3.5, los métodos de extensión se declaran solo en clases estáticas y permiten la
inclusión de métodos personalizados en los objetos para realizar algunas operaciones de consulta
precisas para extender una clase sin ser un miembro real de esa clase. Estos también se pueden
sobrecargar.
En pocas palabras, los métodos de extensión se utilizan para traducir expresiones de consulta en
llamadas a métodos tradicionales (orientadas a objetos).
Diferencia entre LINQ y procedimiento almacenado
Existe una gran variedad de diferencias entre LINQ y los procedimientos almacenados. Estas diferencias
se mencionan a continuación.
Los procedimientos almacenados son mucho más rápidos que una consulta LINQ, ya que
siguen un plan de ejecución esperado.
Es fácil evitar errores de tiempo de ejecución al ejecutar una consulta LINQ que en comparación
con un procedimiento almacenado, ya que el primero tiene soporte Intellisense de Visual Studio,
así como la verificación de tipo completo durante el tiempo de compilación.
LINQ permite la depuración haciendo uso del depurador .NET que no es en el caso de
procedimientos almacenados.
LINQ ofrece soporte para múltiples bases de datos en contraste con los procedimientos
almacenados, donde es esencial reescribir el código para diversos tipos de bases de datos.
El despliegue de la solución basada en LINQ es fácil y simple en comparación con el despliegue

de un conjunto de procedimientos almacenados.
Necesidad de LINQ
Antes de LINQ, era esencial aprender C #, SQL y varias API que unían ambas para formar una aplicación
completa. Desde entonces, estas fuentes de datos y lenguajes de programación enfrentan un desajuste
de impedancia; Se siente la necesidad de una codificación corta.
A continuación se muestra un ejemplo de cuántas técnicas diversas fueron utilizadas por los
desarrolladores al consultar datos antes del advenimiento de LINQ.
SqlConnection sqlConnection = new SqlConnection(connectString);

SqlConnection.Open();
System.Data.SqlClient.SqlCommand sqlCommand = new SqlCommand();

sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = "Select * from Customer";

return sqlCommand.ExecuteReader (CommandBehavior.CloseConnection)
Curiosamente, fuera de las líneas de código presentadas, la consulta se define solo por las dos últimas.
Usando LINQ, la misma consulta de datos puede escribirse en un formato de código de color legible
como el siguiente mencionado a continuación que también en muy poco tiempo.
Northwind db = new Northwind(@"C:\Data\Northwnd.mdf");

var query = from c in db.Customers select c;
Ventajas de LINQ
LINQ ofrece una serie de ventajas y, entre ellas, la más destacada es su poderosa expresividad que
permite a los desarrolladores expresarse de manera declarativa. Algunas de las otras ventajas de LINQ
se dan a continuación.
LINQ ofrece resaltado de sintaxis que resulta útil para descubrir errores durante el tiempo de
diseño.
LINQ ofrece IntelliSense, lo que significa escribir consultas más precisas fácilmente.
Escribir códigos es bastante más rápido en LINQ y, por lo tanto, el tiempo de desarrollo también
se reduce significativamente.
LINQ facilita la depuración debido a su integración en el lenguaje C #.
Ver la relación entre dos tablas es fácil con LINQ debido a su función jerárquica y esto permite
componer consultas uniendo múltiples tablas en menos tiempo.
LINQ permite el uso de una única sintaxis LINQ mientras se consultan muchas fuentes de datos
diversas, y esto se debe principalmente a su base unitiva.
LINQ es extensible, lo que significa que es posible utilizar el conocimiento de LINQ para
consultar nuevos tipos de fuentes de datos.
LINQ ofrece la posibilidad de unir varias fuentes de datos en una sola consulta, así como dividir
problemas complejos en un conjunto de consultas cortas fáciles de depurar.
LINQ ofrece una transformación fácil para la conversión de un tipo de datos a otro, como la
transformación de datos SQL a datos XML.
LINQ - Configuración del entorno
Antes de comenzar con los programas LINQ, lo mejor es comprender primero los matices de configurar
un entorno LINQ. LINQ necesita un marco .NET, una plataforma revolucionaria para tener un tipo diverso
de aplicaciones. Una consulta LINQ se puede escribir en C # o Visual Basic convenientemente.
Microsoft ofrece herramientas para ambos lenguajes, es decir, C # y Visual Basic mediante Visual Studio.
Todos nuestros ejemplos están compilados y escritos en Visual Studio 2010. Sin embargo, la edición
Visual Basic 2013 también está disponible para su uso. Es la última versión y tiene muchas similitudes
con Visual Studio 2012.
Obtener Visual Studio 2010 instalado en Windows 7
Visual Studio se puede instalar desde un medio de instalación como un DVD. Se requieren credenciales
de administrador para instalar Visual Basic 2010 en su sistema con éxito. Es vital desconectar todos los
USB extraíbles del sistema antes de la instalación; de lo contrario, la instalación podría fallar. Algunos de
los requisitos de hardware esenciales para tener para la instalación son los siguientes.
Requisitos de hardware
1.6 GHz o más

1 GB de RAM
3 GB (espacio disponible en el disco duro)
Unidad de disco duro de 5400 RPM
Tarjeta de video compatible con DirectX 9
Unidad de DVD-ROM
Pasos de instalación
Paso 1 : Primero, después de insertar el DVD con el paquete Visual Studio 2010, haga clic en Instalar o
ejecutar el programa desde su medio que aparece en un cuadro emergente en la pantalla.
Paso 2 : ahora configurado en Visual Studio aparecerá en la pantalla. Elija Instalar Microsoft Visual
Studio 2010 .
Paso 3 : tan pronto como haga clic, se iniciará el proceso y aparecerá una ventana de configuración en
su pantalla. Después de completar la carga de los componentes de instalación, lo que llevará algún
tiempo, haga clic en el botón Siguiente para pasar al siguiente paso.
Paso 4 : este es el último paso de la instalación y aparecerá una página de inicio en la que simplemente
elija "He leído y acepto los términos de la licencia" y haga clic en el botón Siguiente .
Paso 5 : ahora seleccione las características para instalar desde la página de opciones que aparece en
su pantalla. Puede elegir la opción Completa o Personalizada . Si tiene menos espacio en disco que el
requerido, como se muestra en los requisitos de espacio en disco, vaya a Personalizado.
Paso 6 : cuando elige la opción personalizada, aparecerá la siguiente ventana. Seleccione las funciones
que desea instalar y haga clic en Actualizar o vaya al paso 7. Sin embargo, se recomienda no ir con la
opción personalizada, ya que en el futuro, puede necesitar las funciones que ha elegido no tener.
Paso 7 : pronto se mostrará una ventana emergente y se iniciará la instalación, lo que puede llevar
mucho tiempo. Recuerde, esto es para instalar todos los componentes.
Paso 8 : finalmente, podrá ver un mensaje en una ventana que indica que la instalación se ha
completado correctamente. Haz clic en Finalizar .
Escribir el programa C # usando LINQ en Visual Studio 2010

Inicie Visual Studio 2010 Ultimate Edition y elija Archivo seguido de Nuevo proyecto en el menú.
Aparecerá un nuevo cuadro de diálogo del proyecto en su pantalla.
Ahora elija Visual C # como categoría en las plantillas instaladas y luego elija la plantilla de la
Aplicación de consola como se muestra en la figura a continuación.
Dé un nombre a su proyecto en el cuadro de nombre inferior y presione OK.
El nuevo proyecto aparecerá en el Explorador de soluciones en el lado derecho de un nuevo

cuadro de diálogo en su pantalla.
Ahora elija Program.cs del Explorador de soluciones y puede ver el código en la ventana del
editor que comienza con 'usar el sistema'.
Aquí puede comenzar a codificar su siguiente programa C #.
using System;
using System.Linq;
using System.Text;
namespace HelloWorld {
class Program {
static void Main(string[] args) {
Console.WriteLine("Hello World")
Console.ReadKey();
}
}
}
Presione la tecla F5 y ejecute su proyecto. Se recomienda guardar el proyecto seleccionando

Archivo → Guardar todo antes de ejecutar el proyecto.
Escribir un programa VB usando LINQ en Visual Studio 2010
Inicie Visual Studio 2010 Ultimate Edition y elija Archivo seguido de Nuevo proyecto en el menú.
Aparecerá un nuevo cuadro de diálogo del proyecto en su pantalla.
Ahora elija Visual Basic como categoría en plantillas instaladas y luego elija Plantilla de
aplicación de consola.
Dé un nombre a su proyecto en el cuadro de nombre inferior y presione OK.
Obtendrá una pantalla con Module1.vb. Comience a escribir su código VB aquí usando LINQ.
Module Module1
Sub Main()
Console.WriteLine("Hello World")
Console.ReadLine()
End Sub
End Module
Presione la tecla F5 y ejecute su proyecto. Se recomienda guardar el proyecto seleccionando

Archivo → Guardar todo antes de ejecutar el proyecto.
Cuando el código anterior de C # o VB se agrupa y ejecuta, produce el siguiente resultado:
Hello World
LINQ - Operadores de consultas
Un conjunto de métodos de extensión que forman un patrón de consulta se conoce como operadores de
consulta estándar de LINQ. Como bloques de construcción de expresiones de consulta LINQ, estos
operadores ofrecen una gama de capacidades de consulta como filtrado, clasificación, proyección,
agregación, etc.
Los operadores de consulta estándar de LINQ se pueden clasificar en los siguientes en función de su
funcionalidad.
Operadores de filtrado
Únete a los operadores
Operaciones de proyección
Operadores de clasificación
Operadores de agrupamiento
Conversiones
Concatenación
Agregación
Operaciones de cuantificador
Operaciones de partición
Operaciones de generacion
Establecer operaciones
Igualdad
Operadores de elementos
Operadores de filtrado
El filtrado es una operación para restringir el conjunto de resultados de modo que solo tenga elementos
seleccionados que satisfagan una condición particular.
Mostrar ejemplos
Descripción C # Sintaxis de Sintaxis de expresión

Operador
expresión de consulta de consulta de VB
dónde Filtrar valores basados en una función de dónde Dónde

predicado
OfType Filtrar valores en función de su capacidad No aplica No aplica

para ser como un tipo especificado
Únete a los operadores
Unirse se refiere a una operación en la que se dirigen fuentes de datos con relaciones difíciles de seguir
entre sí de manera directa.
Mostrar ejemplos

Operador
Unirse El operador une dos secuencias en unirse ... en ... en ... es De x In ..., y In ...
función de teclas coincidentes igual a ... Donde xa = ya
GroupJoin Une dos secuencias y agrupa los unirse ... en ... en ... es Unirse al grupo ... En ...
elementos coincidentes igual a ... en ... En ...
Operaciones de proyección
La proyección es una operación en la que un objeto se transforma en una forma completamente nueva
con solo propiedades específicas.
Mostrar ejemplos
Operador Descripción C # Sintaxis de Sintaxis de

expresión de consulta expresión de
consulta de VB
Seleccionar El operador proyecta valores en función seleccionar Seleccionar

de una función de transformación
Seleccionar El operador proyecta las secuencias de Usar múltiples de Usar múltiples

muchos valores que se basan en una función de cláusulas cláusulas From
transformación y las aplana en una sola
secuencia.
Operadores de clasificación
Una operación de clasificación permite ordenar los elementos de una secuencia en función de uno o más
atributos.
Mostrar ejemplos

consulta de
VB
OrderBy El operador ordena los valores en orden ordenar Ordenar por

ascendente
OrderByDescending El operador ordena los valores en orden ordenar por ... Ordenar por
descendente descendente ...
descendente
Entonces por Ejecuta una clasificación secundaria en ordenado ..., ... Ordenar por
orden ascendente ..., ...
EntoncesPor Ejecuta una clasificación secundaria en ordenado ..., ... Ordenar por
Descendente orden descendente. descendiendo ..., ...
descendiendo
Marcha atrás Realiza una inversión del orden de los No aplica No aplica
elementos en una colección.
Operadores de agrupamiento
Los operadores colocan los datos en algunos grupos en función de un atributo compartido común.
Mostrar ejemplos

Operador
Agrupar Organice una secuencia de elementos en grupo ... por -o- grupo ... Agrupar ... Por ... En ...
por grupos y devuélvalos como una colección por ... en ...
IEnumerable de tipo IGrouping <key,
element>
Para Ejecute una operación de agrupación en No aplica No aplica

buscar la que se devuelve una secuencia de
pares de claves
Conversiones
Los operadores cambian el tipo de objetos de entrada y se utilizan en una amplia gama de aplicaciones.
Mostrar ejemplos

consulta de VB
AsEnumerable Devuelve la entrada escrita como No aplica No aplica

IEnumerable <T>
AsQueryable Un (genérico) IEnumerable se convierte No aplica No aplica

en un (genérico) IQueryable
Emitir Realiza la conversión de elementos de Utilice una variable de De ... Como ...
una colección a un tipo específico rango explícitamente
escrita. Por ejemplo: de
string str en palabras
OfType Filtra los valores en función de sus No aplica No aplica

valores, dependiendo de su capacidad
para emitir a un tipo particular
ToArray Fuerza la ejecución de la consulta y No aplica No aplica

realiza la conversión de una colección a
una matriz
ToDictionary Sobre la base de una función de selector No aplica No aplica

de teclas, establece elementos en un
Diccionario <TKey, TValue> y fuerza la
ejecución de una consulta LINQ
Listar Fuerza la ejecución de una consulta al No aplica No aplica

convertir una colección en una Lista <T>
Para buscar Fuerza la ejecución de una consulta y No aplica No aplica

coloca elementos en una búsqueda
<TKey, TElement> en función de una
función de selector de teclas
Concatenación
Realiza la concatenación de dos secuencias y es bastante similar al operador de la Unión en términos de

su operación, excepto por el hecho de que esto no elimina duplicados.
Mostrar ejemplos

Operador
Concat Dos secuencias se concatenan para la No aplica No aplica

formación de una sola secuencia.
Agregación
Realiza cualquier tipo de agregación deseada y permite crear agregaciones personalizadas en LINQ.
Mostrar ejemplos

Operador
Agregar Opera en los valores de una colección No aplica No aplica

para realizar una operación de agregación
personalizada
Promedio Se calcula el valor promedio de una No aplica Agregado ... En ... En

colección de valores. promedio ()
Contar Cuenta los elementos que satisfacen una No aplica Agregado ... En ... En
función de predicado dentro de la Cuenta ()
colección
LonCount Cuenta los elementos que satisfacen una No aplica Agregado ... En ... En
función de predicado dentro de una gran LongCount ()
colección
Max Descubre el valor máximo dentro de una No aplica Agregado ... En ... En
colección Max ()
Min Descubra el valor mínimo existente dentro No aplica Agregado ... En ... En
de una colección Min ()
Suma Descubre la suma de valores dentro de No aplica Agregado ... En ... En

una colección Suma ()
Operaciones de cuantificador
Estos operadores devuelven un valor booleano, es decir, Verdadero o Falso cuando algunos o todos los
elementos dentro de una secuencia satisfacen una condición específica.
Mostrar ejemplos

Operador
Todas Devuelve un valor 'Verdadero' si todos los No aplica Agregado ... En ... En
elementos de una secuencia satisfacen Todos (...)
una condición de predicado
Alguna Determina mediante la búsqueda de una No aplica Agregado ... En ... En

secuencia que si algún elemento del Cualquiera ()
mismo cumple una condición específica
Contiene Devuelve un valor 'Verdadero' si No aplica No aplica

encuentra que un elemento específico
está allí en una secuencia si la secuencia
no contiene ese elemento específico, se
devuelve el valor 'falso'
Operadores de partición
Divida una secuencia de entrada en dos secciones separadas sin reorganizar los elementos de la
secuencia y luego devolver una de ellas.
Mostrar ejemplos

Operador
Omitir Omite un número específico de elementos No aplica Omitir

dentro de una secuencia y devuelve los
restantes.
SkipWhile Igual que el de Omitir, con la única No aplica Saltar mientras

excepción de que el número de elementos
a omitir se especifica mediante una
condición booleana
Tomar Tome un número específico de elementos No aplica Tomar

de una secuencia y omita los restantes.
TakeWhile Igual que el de Take, excepto el hecho de No aplica Tomar mientras

que el número de elementos a tomar está
especificado por una condición booleana
Operaciones de generacion
Los operadores generacionales crean una nueva secuencia de valores.
Mostrar ejemplos

consulta de VB
DefaultIfEmpty Cuando se aplica a una secuencia vacía, No aplica No aplica

genera un elemento predeterminado
dentro de una secuencia
Vacío Devuelve una secuencia de valores vacía No aplica No aplica

y es el operador generacional más simple
Distancia Genera una colección que tiene una No aplica No aplica

secuencia de enteros o números.
Repetir Genera una secuencia que contiene No aplica No aplica

valores repetidos de una longitud
específica.
Establecer operaciones
Hay cuatro operadores para las operaciones de conjunto, cada uno con un resultado basado en
diferentes criterios.
Mostrar ejemplos
Descripción C # Sintaxis de Sintaxis de

Operador expresión de consulta expresión de
consulta de VB
Distinto Da como resultado una lista de valores No aplica Distinto

únicos de una colección al filtrar datos
duplicados, si los hay
Excepto Compara los valores de dos colecciones y No aplica No aplica

devuelve los de una colección que no
están en la otra colección
Intersecarse Devuelve el conjunto de valores No aplica No aplica

encontrados t idénticos en dos
colecciones separadas
Unión Combina el contenido de dos colecciones No aplica No aplica

diferentes en una sola lista que también
sin contenido duplicado
Igualdad
Compara dos oraciones (enumerables) y determina si son una coincidencia exacta o no.
Mostrar ejemplos
Operador Descripción C # Sintaxis de Sintaxis de expresión

Secuencia Da como resultado un valor booleano si se No aplica No aplica

Igual encuentra que dos secuencias son
idénticas entre sí
Operadores de elementos
Excepto el DefaultIfEmpty, los restantes ocho operadores de elementos de consulta estándar devuelven
un único elemento de una colección.
Mostrar ejemplos

consulta de
VB
ElementAt Devuelve un elemento presente dentro de No aplica No aplica

un índice específico en una colección
ElementAtOrDefault Igual que ElementAt, excepto por el hecho No aplica No aplica

de que también devuelve un valor
predeterminado en caso de que el índice
específico esté fuera de rango
primero Recupera el primer elemento dentro de No aplica No aplica

una colección o el primer elemento que
satisface una condición específica
FirstOrDefault Igual que Primero, excepto el hecho de No aplica No aplica

que también devuelve un valor
predeterminado en caso de que no existan
dichos elementos.
Último Recupera el último elemento presente en No aplica No aplica

una colección o el último elemento que
cumple una condición específica
LastOrDefault Igual que Last excepto el hecho de que No aplica No aplica

también devuelve un valor predeterminado
en caso de que no exista tal elemento
Soltero Devuelve el elemento solitario de una No aplica No aplica

colección o el elemento solitario que
cumple una determinada condición.
SingleOrDefault Igual que Single, excepto que también No aplica No aplica

devuelve un valor predeterminado si no
existe ningún elemento solitario
DefaultIfEmpty Devuelve un valor predeterminado si la No aplica No aplica

colección o lista está vacía o nula
LINQ - SQL
LINQ to SQL ofrece una infraestructura (tiempo de ejecución) para la gestión de datos relacionales como
objetos. Es un componente de la versión 3.5 de .NET Framework y hábilmente traduce consultas SQL
integradas en el lenguaje del modelo de objetos. Estas consultas se envían a la base de datos con el fin
de su ejecución. Después de obtener los resultados de la base de datos, LINQ to SQL nuevamente los
traduce a objetos.
Introducción de LINQ To SQL

Para la mayoría de los desarrolladores de ASP.NET, LINQ to SQL (también conocido como DLINQ) es
una parte electrizante de Language Integrated Query, ya que permite consultar datos en la base de datos
del servidor SQL mediante expresiones LINQ habituales. También permite actualizar, eliminar e insertar
datos, pero el único inconveniente que sufre es su limitación a la base de datos del servidor SQL. Sin
embargo, hay muchos beneficios de LINQ to SQL sobre ADO.NET, como complejidad reducida, pocas
líneas de codificación y muchos más.
A continuación se muestra un diagrama que muestra la arquitectura de ejecución de LINQ to SQL.
¿Cómo usar LINQ to SQL?

Paso 1 - Haga una nueva "Conexión de datos" con el servidor de base de datos. Ver y arrar; Server
Explorer & arrar; Conexiones de datos & arrar; Agregar conexión
Paso 2 : agregar LINQ al archivo de clase SQL
Paso 3 : seleccione tablas de la base de datos y arrastre y suelte en el nuevo archivo de clase LINQ to
SQL.
Paso 4 : tablas agregadas al archivo de clase.
Consultar con LINQ to SQL
Las reglas para ejecutar una consulta con LINQ to SQL son similares a las de una consulta LINQ
estándar, es decir, la consulta se ejecuta diferida o inmediata. Hay varios componentes que juegan un
papel en la ejecución de una consulta con LINQ to SQL y estos son los siguientes.
API de LINQ to SQL : solicita la ejecución de consultas en nombre de una aplicación y la envía
a LINQ to SQL Provider.
Proveedor LINQ to SQL : convierte la consulta a Transact SQL (T-SQL) y envía la nueva
consulta al proveedor ADO para su ejecución.
Proveedor de ADO : después de la ejecución de la consulta, envíe los resultados en forma de

DataReader a LINQ to SQL Provider, que a su vez la convierte en una forma de objeto de
usuario.
Cabe señalar que antes de ejecutar una consulta LINQ to SQL, es vital conectarse a la fuente de datos a
través de la clase DataContext.
Insertar, actualizar y eliminar usando LINQ To SQL
Agregar o insertar
C#
using System;
using System.Linq;
namespace LINQtoSQL {
class LinqToSQLCRUD {
string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["Lin
LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);
//Create new Employee
Employee newEmployee = new Employee();

newEmployee.Name = "Michael";
newEmployee.Email = "yourname@companyname.com";
newEmployee.ContactNo = "343434343";
newEmployee.DepartmentId = 3;
newEmployee.Address = "Michael - USA";
//Add new Employee to database

db.Employees.InsertOnSubmit(newEmployee);
//Save changes to Database.

db.SubmitChanges();
//Get new Inserted Employee

Employee insertedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("Michael"));
Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Addres

insertedEmployee.EmployeeId, insertedEmployee.Name, insertedEmployee.E
insertedEmployee.ContactNo, insertedEmployee.Address);
Console.WriteLine("\nPress any key to continue.");

Console.ReadKey();
}
}
}
VB
Module Module1
Sub Main()
Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings(
Dim db As New LinqToSQLDataContext(connectString)
Dim newEmployee As New Employee()
newEmployee.Name = "Michael"
newEmployee.Email = "yourname@companyname.com"
newEmployee.ContactNo = "343434343"
E l D t tIdd 3
newEmployee.DepartmentId = 3
newEmployee.Address = "Michael - USA"
db.Employees.InsertOnSubmit(newEmployee)
db.SubmitChanges()
Dim insertedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("
Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3},

Address = {4}", insertedEmployee.EmployeeId, insertedEmployee.Name,
insertedEmployee.Email, insertedEmployee.ContactNo, insertedEmployee.Address)
Console.WriteLine(vbLf & "Press any key to continue.")

Console.ReadKey()
End Sub
End Module
Emplyee ID = 4, Name = Michael, Email = yourname@companyname.com, ContactNo =

343434343, Address = Michael - USA
Press any key to continue.
Actualizar
C#
using System;
using System.Linq;
LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);
//Get Employee for update

Employee employee = db.Employees.FirstOrDefault(e =>e.Name.Equals("Michael"));
employee.Name = "George Michael";

employee.Email = "yourname@companyname.com";
employee.ContactNo = "99999999";
employee.DepartmentId = 2;
employee.
employee Address = "Michael George - UK";
employee.Address = Michael George UK ;

db.SubmitChanges();
//Get Updated Employee

Employee updatedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michae
Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Addres

updatedEmployee.EmployeeId, updatedEmployee.Name, updatedEmployee.Emai
updatedEmployee.ContactNo, updatedEmployee.Address);

Console.ReadKey();
}
}
}
VB
Module Module1
Sub Main()
Dim employee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"
employee.Name = "George Michael"

employee.Email = "yourname@companyname.com"
employee.ContactNo = "99999999"
employee.DepartmentId = 2
employee.Address = "Michael George - UK"
db.SubmitChanges()
Dim updatedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("G
Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3},

Address = {4}", updatedEmployee.EmployeeId, updatedEmployee.Name,
updatedEmployee.Email, updatedEmployee.ContactNo, updatedEmployee.Address)

Console.ReadKey()
End Sub
End Module
Cuando el código anterior de C # o Vb se compila y ejecuta, produce el siguiente resultado:
Emplyee ID = 4, Name = George Michael, Email = yourname@companyname.com, ContactNo =

999999999, Address = Michael George - UK
Eliminar
C#
using System;
using System.Linq;
LinqToSQLDataContext db = newLinqToSQLDataContext(connectString);
//Get Employee to Delete

Employee deleteEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael
//Delete Employee
db.Employees.DeleteOnSubmit(deleteEmployee);

db.SubmitChanges();
//Get All Employee from Database

var employeeList = db.Employees;
foreach (Employee employee in employeeList) {
Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo);

Console.ReadKey();
}
}
}
VB
Module Module1
Sub Main()
Dim deleteEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Ge
db.Employees.DeleteOnSubmit(deleteEmployee)
db.SubmitChanges()
Dim employeeList = db.Employees
For Each employee As Employee In employeeList

Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo)
Next

Console.ReadKey()
End Sub
End Module
Emplyee ID = 1, Name = William, Email = abc@gy.co, ContactNo = 999999999

Emplyee ID = 2, Name = Miley, Email = amp@esds.sds, ContactNo = 999999999
Emplyee ID = 3, Name = Benjamin, Email = asdsad@asdsa.dsd, ContactNo =
LINQ - Objetos
LINQ to Objects ofrece el uso de cualquier consulta LINQ que admita IEnumerable <T> para acceder a
colecciones de datos en memoria sin necesidad de un proveedor LINQ (API) como en el caso de LINQ to
SQL o LINQ to XML.
Introducción de LINQ a objetos

Las consultas en LINQ to Objects devuelven variables de tipo, generalmente IEnumerable <T>
solamente. En resumen, LINQ to Objects ofrece un nuevo enfoque a las colecciones, ya que antes era
vital escribir una codificación larga (bucles foreach de mucha complejidad) para recuperar datos de una
colección que ahora se reemplaza escribiendo un código declarativo que describa claramente los datos
deseados. eso es necesario para recuperar.
También hay muchas ventajas de LINQ to Objects sobre los bucles foreach tradicionales, como mayor
legibilidad, filtrado potente, capacidad de agrupación, ordenamiento mejorado con codificación de
aplicación mínima. Estas consultas LINQ también son de naturaleza más compacta y son portables a
cualquier otra fuente de datos sin ninguna modificación o con solo una pequeña modificación.
A continuación se muestra un ejemplo simple de LINQ to Objects:
using System;
using System.Linq;
using System.Text;
namespace LINQtoObjects {
class Program {
string[] tools = { "Tablesaw", "Bandsaw", "Planer", "Jointer", "Drill", "Sander" };

var list = from t in tools select t;
StringBuilder sb = new StringBuilder();
foreach (string s in list) {

sb.Append(s + Environment.NewLine);
}
Console.WriteLine(sb.ToString(), "Tools");
Console.ReadLine();
}
}
}
En el ejemplo, una matriz de cadenas (herramientas) se utiliza como la colección de objetos que se
consultarán mediante LINQ to Objects.
Objects query is:

var list = from t in tools select t;
Tablesaw
Bandsaw
Planer
Jointer
Drill
Sander
Consulta en colecciones de memoria usando LINQ to Objects
C#
using System;
using System.Linq;
namespace LINQtoObjects {
class Department {
public int DepartmentId { get; set; }
public string Name { get; set; }
}
class LinqToObjects {
List<Department> departments = new List<Department>();
departments.Add(new Department { DepartmentId = 1, Name = "Account" });

departments.Add(new Department { DepartmentId = 2, Name = "Sales" });
departments.Add(new Department { DepartmentId = 3, Name = "Marketing" });
var departmentList = from d in departments

select d;
foreach (var dept in departmentList) {

Console.WriteLine("Department Id = {0} , Department Name = {1}",
dept.DepartmentId, dept.Name);
}

Console.ReadKey();
}
}
}
VB
Imports System.Collections.Generic
Imports System.Linq
Module Module1
Sub Main(ByVal args As String())
Dim account As New Department With {.Name = "Account", .DepartmentId = 1}

Dim sales As New Department With {.Name = "Sales", .DepartmentId = 2}
Dim marketing As New Department With {.Name = "Marketing", .DepartmentId = 3}
Dim departments As New System.Collections.Generic.List(Of Department)(New Department() {ac
Dim departmentList = From d In departments
For Each dept In departmentList

Console.WriteLine("Department Id = {0} , Department Name = {1}", dept.DepartmentId, dep
Next

Console.ReadKey()
End Sub
Class Department
Public Property Name As String
Public Property DepartmentId As Integer
End Class
End Module
Department Id = 1, Department Name = Account

Department Id = 2, Department Name = Sales
Department Id = 3, Department Name = Marketing
LINQ - Conjunto de datos
Un conjunto de datos ofrece una representación de datos extremadamente útil en la memoria y se utiliza
para una amplia gama de aplicaciones basadas en datos. LINQ to Dataset como una de las tecnologías
de LINQ to ADO.NET facilita la realización de consultas sobre los datos de un conjunto de datos de una
manera sin problemas y mejora la productividad.
Introducción de LINQ al conjunto de datos
LINQ to Dataset ha simplificado la tarea de consulta para los desarrolladores. No necesitan escribir
consultas en un lenguaje de consulta específico, sino que lo mismo se puede escribir en lenguaje de
programación. LINQ to Dataset también se puede usar para consultar dónde se consolidan los datos de
múltiples fuentes de datos. Esto tampoco necesita ningún proveedor de LINQ, como LINQ to SQL y LINQ
to XML para acceder a los datos de las colecciones de memoria.
A continuación se muestra un ejemplo simple de una consulta LINQ to Dataset en la que primero se
obtiene una fuente de datos y luego el conjunto de datos se llena con dos tablas de datos. Se establece
una relación entre ambas tablas y se crea una consulta LINQ contra ambas tablas mediante una cláusula
de unión. Finalmente, foreach loop se usa para mostrar los resultados deseados.
C#
using System;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LINQtoDataset {
class Program {
string sqlSelect = "SELECT * FROM Department;" + "SELECT * FROM Employee;";
// Create the data adapter to retrieve data from the database

SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);
// Create table mappings

da.TableMappings.Add("Table", "Department");
da.TableMappings.Add("Table1", "Employee");
// Create and fill the DataSet

DataSet ds = new DataSet();
da.Fill(ds);
DataRelation dr = ds.Relations.Add("FK_Employee_Department",
ds.Tables["Department"].Columns["DepartmentId"],
ds.Tables["Employee"].Columns["DepartmentId"]);
DataTable department = ds.Tables["Department"];

DataTable employee = ds.Tables["Employee"];
var query = from d in department.AsEnumerable()

join e in employee.AsEnumerable()
on d.Field<int>("DepartmentId") equals
e.Field<int>("DepartmentId")
select new {
EmployeeId = e.Field<int>("EmployeeId"),
Name = e.Field<string>("Name"),
DepartmentId = d.Field<int>("DepartmentId"),
DepartmentName = d.Field<string>("Name")
};
foreach (var q in query) {

Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}",

q.EmployeeId, q.Name, q.DepartmentName);
}

Console.ReadKey();
}
}
}
VB
Imports System.Data.SqlClient
Imports System.Linq
Module LinqToDataSet
Sub Main()
Dim sqlSelect As String = "SELECT * FROM Department;" + "SELECT * FROM Employee;"

Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
sqlCnn.Open()
Dim da As New SqlDataAdapter

da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)
da.TableMappings.Add("Table", "Department")
da.TableMappings.Add("Table1", "Employee")
Dim ds As New DataSet()

da.Fill(ds)
Dim dr As DataRelation = ds.Relations.Add("FK_Employee_Department", ds.Tables("Department"
Dim department As DataTable = ds.Tables("Department")

Dim employee As DataTable = ds.Tables("Employee")
Dim query = From d In department.AsEnumerable()

Join e In employee.AsEnumerable() On d.Field(Of Integer)("DepartmentId") Equal
e.Field(Of Integer)("DepartmentId")
Select New Person With { _
.EmployeeId = e.Field(Of Integer)("EmployeeId"),
.EmployeeName = e.Field(Of String)("Name"),
.DepartmentId = d.Field(Of Integer)("DepartmentId"),
.DepartmentName = d.Field(Of String)("Name")
}
h
For Each e In query
Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}", e.EmployeeI
Next

Console.ReadKey()
End Sub
Class Person
Public Property EmployeeId As Integer
Public Property EmployeeName As String
Public Property DepartmentName As String
End Class
End Module
Employee Id = 1, Name = William, Department Name = Account

Employee Id = 2, Name = Benjamin, Department Name = Account
Employee Id = 3, Name = Miley, Department Name = Sales
Consultar conjunto de datos usando LinQ a conjunto de datos

Antes de comenzar a consultar un conjunto de datos usando LINQ to Dataset, es vital cargar los datos en
un conjunto de datos y esto se hace usando la clase DataAdapter o LINQ to SQL. La formulación de
consultas usando LINQ to Dataset es bastante similar a la formulación de consultas usando LINQ junto
con otras fuentes de datos habilitadas para LINQ.
Consulta de tabla única
En la siguiente consulta de tabla única, todos los pedidos en línea se recopilan de

SalesOrderHeaderTtable y, a continuación, el ID del pedido, la fecha del pedido y el número de pedido se
muestran como salida.
C#
using System;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
i {
namespace LinqToDataset {
class SingleTable {
string sqlSelect = "SELECT * FROM Department;";
// Create the data adapter to retrieve data from the database

SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);
// Create table mappings

da.TableMappings.Add("Table", "Department");
// Create and fill the DataSet

DataSet ds = new DataSet();
da.Fill(ds);
DataTable department = ds.Tables["Department"];
var query = from d in department.AsEnumerable()

select new {
DepartmentId = d.Field<int>("DepartmentId"),
DepartmentName = d.Field<string>("Name")
};
foreach (var q in query) {

Console.WriteLine("Department Id = {0} , Name = {1}",
q.DepartmentId, q.DepartmentName);
}

Console.ReadKey();
}
}
}
VB
Imports System.Data.SqlClient
Imports System.Linq
Module LinqToDataSet
Sub Main()
Dim sqlSelect As String = "SELECT * FROM Department;"

Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
sqlCnn.
sqlCnn Open()
sqlCnn.Open()
Dim da As New SqlDataAdapter

da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)
da.TableMappings.Add("Table", "Department")
Dim ds As New DataSet()
da.Fill(ds)
Dim department As DataTable = ds.Tables("Department")
Dim query = From d In department.AsEnumerable()
Select New DepartmentDetail With {

.DepartmentId = d.Field(Of Integer)("DepartmentId"),
.DepartmentName = d.Field(Of String)("Name")
}
For Each e In query

Console.WriteLine("Department Id = {0} , Name = {1}", e.DepartmentId, e.DepartmentName)
Next

Console.ReadKey()
End Sub
Public Class DepartmentDetail

Public Property DepartmentName As String
End Class
End Module
Department Id = 1, Name = Account

Department Id = 2, Name = Sales
Department Id = 3, Name = Pre-Sales
Department Id = 4, Name = Marketing
LINQ - XML
LINQ to XML ofrece una fácil accesibilidad a todas las funcionalidades de LINQ como operadores de
consulta estándar, interfaz de programación, etc. Integrado en el marco .NET, LINQ to XML también hace
el mejor uso de las funcionalidades del marco .NET como depuración, verificación en tiempo de
compilación, tipeo fuerte y mucho mas que decir.
Introducción de LINQ to XML
Al usar LINQ to XML, cargar documentos XML en la memoria es fácil y más fácil es consultar y modificar
documentos. También es posible guardar documentos XML existentes en la memoria en el disco y
serializarlos. Elimina la necesidad de que un desarrollador aprenda el lenguaje de consulta XML que es
algo complejo.
LINQ to XML tiene su poder en el espacio de nombres System.Xml.Linq. Esto tiene las 19 clases
necesarias para trabajar con XML. Estas clases son las siguientes.
XAttribute
XCData
XComment
XContainer
XDeclaración
XDocument
XDocumentType
XElement
XName
XNamespace
XNode
XNodeDocumentOrderComparer
XNodeEqualityComparer
XObject
XObjectChange
XObjectChangeEventArgs
XObjectEventHandler
XProcessingInstruction
XText
Leer un archivo XML usando LINQ
C#
using System;
using System.Linq;
using System.Xml.Linq;
namespace LINQtoXML {
class ExampleOfXML {
string myXML = @"<Departments>

<Department>Account</Department>
<Department>Sales</Department>
<Department>Pre-Sales</Department>
<Department>Marketing</Department>
</Departments>";
XDocument xdoc = new XDocument();

xdoc = XDocument.Parse(myXML);
var result = xdoc.Element("Departments").Descendants();
foreach (XElement item in result) {

Console.WriteLine("Department Name - " + item.Value);
}

Console.ReadKey();
}
}
}
VB
Imports System.Linq
Imports System.Xml.Linq
Module Module1
Dim myXML As String = "<Departments>" & vbCr & vbLf &

"<Department>Account</Department>" & vbCr & vbLf &
"<Department>Sales</Department>" & vbCr & vbLf &
"<Department>Pre-Sales</Department>" & vbCr & vbLf &
"<Department>Marketing</Department>" & vbCr & vbLf &
"</Departments>"
Dim xdoc As New XDocument()

xdoc = XDocument.Parse(myXML)
Dim result = xdoc.Element("Departments").Descendants()
For Each item As XElement In result

Console.WriteLine("Department Name - " + item.Value)
Next

Console.ReadKey()
End Sub
End Module
Department Name - Account

Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing
Agregar nuevo nodo
C#
using System;
using System.Linq;

</Departments>";

//Add new Element

xdoc.Element("Departments").Add(new XElement("Department", "Finance"));
//Add new Element at First

xdoc.Element("Departments").AddFirst(new XElement("Department", "Support"));


Console.ReadKey();
}
}
}
VB
Imports System.Linq
Module Module1

"</Departments>"

xdoc.Element("Departments").Add(New XElement("Department", "Finance"))
xdoc.Element("Departments").AddFirst(New XElement("Department", "Support"))

Next

Console.ReadKey()
End Sub
End Module
Department Name - Support

Department Name - Sales

Department Name - Finance
Suprimir Nodo Particular
C#
using System;
using System.Linq;

<Department>Support</Department>
<Department>Finance</Department>
</Departments>";

//Remove Sales Department

xdoc.Descendants().Where(s =>s.Value == "Sales").Remove();

}

Console.ReadKey();
}
}
}
VB
Imports System.Linq
Module Module1
Sub Main(args As String())

"<Department>Support</Department>" & vbCr & vbLf &
"<Department>Finance</Department>" & vbCr & vbLf &
"</Departments>"

xdoc.Descendants().Where(Function(s) s.Value = "Sales").Remove()

Next

Console.ReadKey()
End Sub
End Module
Department Name - Support

Department Name - Finance
LINQ - Entidades
Como parte de ADO.NET Entity Framework, LINQ to Entities es más flexible que LINQ to SQL, pero no
es muy popular debido a su complejidad y falta de características clave. Sin embargo, no tiene las
limitaciones de LINQ to SQL que permite la consulta de datos solo en la base de datos del servidor SQL,
ya que LINQ to Entities facilita la consulta de datos en una gran cantidad de proveedores de datos como
Oracle, MySQL, etc.
Además, tiene un gran apoyo de ASP.Net en el sentido de que los usuarios pueden utilizar un control de
fuente de datos para ejecutar una consulta a través de LINQ a las entidades y facilita la vinculación de los
resultados sin necesidad de codificación adicional.
Para estas ventajas, LINQ to Entities se ha convertido en el mecanismo estándar para el uso de LINQ en
bases de datos en la actualidad. También es posible con LINQ to Entities cambiar los detalles de los
datos consultados y confirmar fácilmente una actualización por lotes. El hecho más interesante sobre
LINQ to Entities es que tiene la misma sintaxis como la de SQL e incluso tiene el mismo grupo de
operadores de consulta estándar como Join, Select, OrderBy, etc.
Proceso de creación y ejecución de consultas de LINQ to Entities

Construcción de una instancia de ObjectQuery a partir de un ObjectContext (Entity
Connection)
Redactar una consulta en C # o Visual Basic (VB) utilizando la instancia recién construida
Conversión de operadores de consulta estándar de LINQ, así como expresiones de LINQ en

árboles de comandos
Ejecutando la consulta pasando cualquier excepción encontrada al cliente directamente
Devolviendo al cliente todos los resultados de la consulta.
ObjectContext es aquí la clase primaria que permite la interacción con Entity Data Model o, en otras
palabras, actúa como un puente que conecta LINQ con la base de datos. Los árboles de comandos son
aquí representación de consultas con compatibilidad con el marco de Entity.
El Entity Framework, por otro lado, es en realidad Mapper Relacional de Objetos abreviado
generalmente como ORM por los desarrolladores que realiza la generación de objetos comerciales y
entidades según las tablas de la base de datos y facilita varias operaciones básicas como crear,
actualizar, eliminar y leer . La siguiente ilustración muestra el marco de la entidad y sus componentes.
Ejemplo de AGREGAR, ACTUALIZAR y ELIMINAR usando LINQ con el modelo de

entidad
Primero agregue el Modelo de entidad siguiendo los pasos a continuación.
Paso 1 : haga clic con el botón derecho en el proyecto y haga clic en Agregar nuevo elemento para abrir
la ventana como se muestra a continuación. Seleccione el modelo de datos de entidad ADO.NET y
especifique el nombre y haga clic en Agregar.
Paso 2 : seleccione Generar a partir de la base de datos.
Paso 3 : elija Conexión de base de datos en el menú desplegable.
Paso 4 : selecciona todas las tablas.
Ahora escribe el siguiente código.
using DataAccess;
using System;
using System.Linq;
namespace LINQTOSQLConsoleApp {
public class LinqToEntityModel {
using (LinqToSQLDBEntities context = new LinqToSQLDBEntities()) {

//Get the List of Departments from Database
var departmentList = from d in context.Departments
select d;

}
//Add new Department

DataAccess.Department department = new DataAccess.Department();
DataAccess.Department department = new DataAccess.Department();
department.Name = "Support";
context.Departments.Add(department);
context.SaveChanges();
Console.WriteLine("Department Name = Support is inserted in Database");
//Update existing Department

DataAccess.Department updateDepartment = context.Departments.FirstOrDefault(d ⇒d.De
updateDepartment.Name = "Account updated";
Console.WriteLine("Department Name = Account is updated in Database");
//Delete existing Department

DataAccess.Department deleteDepartment = context.Departments.FirstOrDefault(d ⇒d.De
context.Departments.Remove(deleteDepartment);
Console.WriteLine("Department Name = Pre-Sales is deleted in Database");
//Get the Updated List of Departments from Database

departmentList = from d in context.Departments
select d;

}
}

Console.ReadKey();
}
}
}
LINQ - Expresiones Lambda
El término 'expresión lambda' deriva su nombre del cálculo 'lambda' que a su vez es una notación
matemática aplicada para definir funciones. Las expresiones Lambda como parte ejecutable de una
ecuación de LINQ traducen la lógica de una manera en tiempo de ejecución para que pueda pasar a la
fuente de datos convenientemente. Sin embargo, las expresiones lambda no se limitan solo a buscar
aplicaciones solo en LINQ.
Estas expresiones se expresan mediante la siguiente sintaxis:
(Input parameters) ⇒ Expression or statement block
Aquí hay un ejemplo de una expresión lambda:
y⇒y*y
La expresión anterior especifica un parámetro llamado y y ese valor de y es cuadrado. Sin embargo, no
es posible ejecutar una expresión lambda de esta forma. A continuación se muestra un ejemplo de una
expresión lambda en C #.
C#
using System;
using System.Linq;
using System.Text;
namespace lambdaexample {
class Program {
delegate int del(int i);

del myDelegate = y ⇒ y * y;
int j = myDelegate(5);
Console.WriteLine(j);
Console.ReadLine();
}
}
}
VB
Module Module1
Private Delegate Function del(ByVal i As Integer) As Integer
Dim myDelegate As del = Function(y) y * y

Dim j As Integer = myDelegate(5)
Console.WriteLine(j)
Console.ReadLine()
End Sub
End Module
25
Expresión lambda
Como la expresión en la sintaxis de la expresión lambda que se muestra arriba está en el lado derecho,
también se conoce como expresión lambda.
Lambdas asíncronas
La expresión lambda creada al incorporar el procesamiento asincrónico mediante el uso de la palabra
clave asíncrona se conoce como lambdas asíncronas. A continuación se muestra un ejemplo de lambda
asíncrona.
Func<Task<string>> getWordAsync = async()⇒ “hello”;
Lambda en operadores de consulta estándar

Una expresión lambda dentro de un operador de consulta es evaluada por el mismo bajo demanda y
trabaja continuamente en cada uno de los elementos en la secuencia de entrada y no en toda la
secuencia. La expresión Lambda permite a los desarrolladores alimentar su propia lógica en los
operadores de consulta estándar. En el ejemplo a continuación, el desarrollador ha utilizado el operador
'Dónde' para reclamar los valores impares de la lista dada utilizando una expresión lambda.
C#
//Get the average of the odd Fibonacci numbers in the series...
using System;
using System.Linq;
using System.Text;
class Program {
int[] fibNum = { 1, 1, 2, 3, 5, 8, 13, 21, 34 };

double averageValue = fibNum.Where(num ⇒ num % 2 == 1).Average();
Console.WriteLine(averageValue);
Console.ReadLine();
}
}
}
VB
Module Module1
Sub Main()
Dim fibNum As Integer() = {1, 1, 2, 3, 5, 8, 13, 21, 34}

Dim averageValue As Double = fibNum.Where(Function(num) num Mod 2 = 1).Average()
Console.WriteLine(averageValue)
Console.ReadLine()
End Sub
End Module
7.33333333333333
Inferencia de tipo en Lambda
En C #, la inferencia de tipos se usa convenientemente en una variedad de situaciones y también sin

especificar los tipos explícitamente. Sin embargo, en el caso de una expresión lambda, la inferencia de
tipos solo funcionará cuando se haya especificado cada tipo, ya que el compilador debe estar satisfecho.
Consideremos el siguiente ejemplo.
delegate int Transformer (int i);
Aquí el compilador emplea la inferencia de tipos para aprovechar el hecho de que x es un número entero
y esto se hace examinando el tipo de parámetro del Transformador.
Alcance variable en la expresión lambda
Hay algunas reglas al usar el alcance variable en una expresión lambda, como las variables que se
inician dentro de una expresión lambda no deben ser visibles en un método externo. También hay una
regla de que una variable capturada no se debe recolectar basura a menos que el delegado que hace
referencia a la misma sea elegible para el acto de recolección de basura. Además, hay una regla que
prohíbe que una declaración return dentro de una expresión lambda provoque la devolución de un
método de cierre.
Aquí hay un ejemplo para demostrar el alcance variable en la expresión lambda.
using System;
using System.Linq;
using System.Text;
class Program {
delegate bool D();
delegate bool D2(int i);
class Test {
D del;
D2 del2;
public void TestMethod(int input) {

int j = 0;
// Initialize the delegates with lambda expressions.
// Note access to 2 outer variables.
// del will be invoked within this method.
del = () ⇒ { j = 10; return j > input; };
// del2 will be invoked after TestMethod goes out of scope.

del2 = (x) ⇒ { return x == j; };
// Demonstrate value of j:
// The delegate has not been invoked yet.
Console.WriteLine("j = {0}", j); // Invoke the delegate.
bool boolResult = del();
Console.WriteLine("j = {0}. b = {1}", j, boolResult);

}

Test test = new Test();
test.TestMethod(5);
// Prove that del2 still has a copy of

// local variable j from TestMethod.
bool result = test.del2(10);
Console.WriteLine(result);
Console.ReadKey();
}
}
}
}
j = 0
j = 10. b = True
True
Árbol de expresión
Las expresiones lambda se usan ampliamente en la construcción del árbol de expresiones . Un árbol de
expresión regala código en una estructura de datos que se asemeja a un árbol en el que cada nodo es en
sí mismo una expresión como una llamada a método o puede ser una operación binaria como x <y. A
continuación se muestra un ejemplo del uso de la expresión lambda para construir un árbol de expresión.
Declaración Lambda
También hay declaraciones lambdas que consisten en dos o tres declaraciones, pero no se usan en la
construcción de árboles de expresión. Una declaración de devolución debe escribirse en una declaración
lambda.
Sintaxis de la declaración lambda
(params)⇒ {statements}
Ejemplo de una declaración lambda
using System.Linq;
using System.Text;
using System.Linq.Expressions;
class Program {
int[] source = new[] { 3, 8, 4, 6, 1, 7, 9, 2, 4, 8 };
foreach (int i in source.Where(x ⇒

{
if (x <= 3)
return true;
else if (x >= 7)
return true;
return false;
}
))
Console.WriteLine(i);
Console.ReadLine();
}
}
}
3
8
1
7
9
2
8
Las lambdas se emplean como argumentos en consultas LINQ basadas en métodos y nunca se les
permite tener un lugar en el lado izquierdo de los operadores como es o como los métodos anónimos.
Aunque las expresiones Lambda son métodos anónimos muy parecidos, estos no están restringidos en
absoluto para ser utilizados solo como delegados.
Puntos para recordar al usar expresiones lambda
Una expresión lambda puede devolver un valor y puede tener parámetros.
Los parámetros se pueden definir de muchas maneras con una expresión lambda.
Si hay una sola declaración en una expresión lambda, no hay necesidad de llaves, mientras que
si hay varias declaraciones, las llaves y el valor de retorno son esenciales para escribir.
Con las expresiones lambda, es posible acceder a las variables presentes fuera del bloque de
expresiones lambda mediante una característica conocida como cierre. El uso del cierre debe
hacerse con precaución para evitar cualquier problema.
Es imposible ejecutar cualquier código inseguro dentro de cualquier expresión lambda.
Las expresiones lambda no deben usarse en el lado izquierdo del operador.
LINQ - ASP.Net
Como un conjunto de extensiones de .NET Framework, LINQ es el mecanismo preferido para el acceso a
datos por parte de los desarrolladores de ASP.NET. ASP.NET 3.5 tiene una herramienta integrada de
control LINQDataSource que permite el uso de LINQ fácilmente en ASP.NET. ASP.NET utiliza el control
mencionado anteriormente como fuente de datos. Los proyectos de la vida real abarcan principalmente
sitios web o aplicaciones de Windows y, por lo tanto, para comprender mejor el concepto de LINQ con
ASP.NET, comencemos por crear un sitio web ASP.NET que haga uso de las características de LINQ.
Para esto, es esencial instalar Visual Studio y .NET Framework en su sistema. Una vez que haya abierto
Visual Studio, vaya a Archivo → Nuevo → Sitio web. Se abrirá una ventana emergente como se muestra
en la figura siguiente.
Ahora, debajo de las plantillas en el lado izquierdo, habrá dos opciones de idioma para crear el sitio web.
Elija Visual C # y seleccione ASP.NET Empty Web Site .
Seleccione la carpeta donde desea guardar el nuevo sitio web en su sistema. Luego presione OK y
pronto aparecerá el Explorador de soluciones en su pantalla que contiene todos los archivos web.
Haga clic derecho en Default.aspx en el Explorador de soluciones y elija Ver en el navegador para ver el
sitio web predeterminado de ASP.NET en el navegador. Pronto su nuevo sitio web ASP.NET se abrirá en
el navegador web, como se muestra en la siguiente captura de pantalla.
.aspx es, de hecho, la extensión de archivo principal utilizada en los sitios web ASP.NET. Visual Studio
crea de forma predeterminada todas las páginas necesarias para un sitio web básico, como la página de
inicio y la página Acerca de nosotros , donde puede colocar su contenido convenientemente. El código
del sitio web se genera automáticamente aquí y también se puede ver.
Control LINQDataSource
Es posible ACTUALIZAR, INSERTAR y ELIMINAR datos en las páginas del sitio web ASP.NET con la
ayuda del control LINQDataSource. No hay absolutamente ninguna necesidad de especificación de
comandos SQL ya que el control LINQDataSource emplea comandos creados dinámicamente para tales
operaciones.
El control permite a un usuario hacer uso de LINQ en una página web ASP.NET convenientemente
mediante la configuración de propiedades en el texto marcado. LINQDataSource es muy similar al de
controles como SqlDataSource y ObjectDataSource, ya que se puede usar para vincular otros controles
ASP.NET presentes en una página a una fuente de datos. Por lo tanto, debemos tener una base de
datos para explicar las diversas funciones invocadas por el control LINQDataSource.
Antes de comenzar a explicar el uso del control en el formulario de la página web ASP.NET, es esencial
abrir Microsoft Visual Studio Toolbox y arrastrar y soltar el control LINQDataSource a la página .aspx del
sitio web ASP.NET como se muestra a continuación.
El siguiente paso es configurar LINQDataSource seleccionando todas las columnas para el registro del
empleado.
Ahora agregue un control GridView a la página .aspx y configúrelo como se muestra en la figura
siguiente. El control GridView es potente y ofrece flexibilidad para trabajar con los datos. Poco después
de configurar el control, aparecerá en el navegador.
La codificación que se puede ver ahora en su pantalla para la página .aspx será:
<!DOCTYPE html>
<html>
<head runat = "server">
<title></title>
</head>
<body>
<form id = "form1" runat = "server">
<div>
<asp:GridView ID = "GridView1" runat = "server" AutoGenerateColumns = "False"
DataKeyNames = "ContactID" DataSourceID = "LINQDataSource1">

<Columns>
<asp:BoundField DataField = "ContactID" HeaderText = "ContactID"

InsertVisible = "False" ReadOnly="True" SortExpression = "ContactID" />
<asp:CheckBoxField DataField = "NameStyle" HeaderText = "NameStyle"
SortExpression = "NameStyle" />
<asp:BoundField DataField = "Title" HeaderText = "Title" SortExpression = "Tit
<asp:BoundField DataField = "FirstName" HeaderText = "FirstName"
SortExpression="FirstName" />
<asp:BoundField DataField = "MiddleName" HeaderText = "MiddleName"
SortExpression = "MiddleName" />
<asp:BoundField DataField = "LastName" HeaderText = "LastName"
SortExpression = "LastName" />
<asp:BoundField DataField = "Suffix" HeaderText = "Suffix"
SortExpression = "Suffix" />
<asp:BoundField DataField = "EmailAddress" HeaderText = "EmailAddress"
SortExpression = "EmailAddress" />
</Columns>
</asp:GridView>
<br />
</div>
<asp:LINQDataSource ID = "LINQDataSource1" runat = "server"
ContextTypeName = "LINQWebApp1.AdventureWorksDataContext" EntityTypeName = ""

TableName = "Contacts">
</asp:LINQDataSource>
</form>
</body>
</html>
Aquí debe tenerse en cuenta que es vital establecer la propiedad ContextTypeName a la de la clase que
representa la base de datos. Por ejemplo, aquí se proporciona como
LINQWebApp1.AdventureWorksDataContext ya que esta acción hará la conexión necesaria entre
LINQDataSource y la base de datos.
INSERTAR, ACTUALIZAR y ELIMINAR datos en la página ASP.NET usando LINQ

Después de completar todos los pasos anteriores con rigor, elegir las tareas LinqDataSource del
control LinqDataSource y selecciona todas las tres cajas para permitir insertar, actualizar y activar
Activar el borrado de la misma, como se muestra en la siguiente captura de pantalla.
Pronto, el marcado declarativo se mostrará en su pantalla como el siguiente.
<asp:LINQDataSource
ContextTypeName = "LINQWebApp1.AdventureWorksDataContext"
TableName = "Contacts"
EnableUpdate = "true"
EnableInsert = "true"
EnableDelete = "true"
ID = "LINQDataSource1"
runat = "server">
</asp:LINQDataSource>
Ahora, dado que hay varias filas y columnas, es mejor agregar otro control en su formulario .aspx
denominado Vista detallada o Control maestro debajo del control Vista de cuadrícula para mostrar solo
los detalles de una fila seleccionada de la cuadrícula. Elija las tareas de Vista detallada desde el control
Vista detallada y seleccione las casillas de verificación como se muestra a continuación.
Ahora, solo guarde los cambios y presione Ctrl + F5 para ver la página en su navegador donde ahora es
posible eliminar, actualizar e insertar cualquier registro en el control de vista detallada.

LINQ - Guía Rápida - Tutorial

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

LINQ - Guía Rápida - Tutorial

Cargado por

Copyright:

Formatos disponibles

8/11/2019 LINQ - Guía rápida - Tutorialspoint

LINQ - Guía rápida

LINQ - Descripción general

Ejemplo de una consulta LINQ

string[] words = {"hello", "wonderful", "LINQ", "beautiful", "world"};

//Get only short words

//Print each word out

' Get only short words

' Print each word out.

For Each word In shortWords

Cuando el código anterior de C # o VB se compila y ejecuta, produce el siguiente resultado:

Hay dos sintaxis de LINQ. Estos son los siguientes.

Sintaxis de Lamda (Método)

var longWords = words.Where( w ⇒ w.length > 10);

Sintaxis de consulta (comprensión)

var longwords = from w in words where w.length > 10;

Los tipos de LINQ se mencionan a continuación en breve.

Arquitectura LINQ en .NET

// Specify the data source.

// Define the query expression.

// Execute the query.

foreach (int i in scoreQuery) {

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Diferencia entre LINQ y procedimiento almacenado

El despliegue de la solución basada en LINQ es fácil y simple en comparación con el despliegue

SqlConnection sqlConnection = new SqlConnection(connectString);

System.Data.SqlClient.SqlCommand sqlCommand = new SqlCommand();

sqlCommand.CommandText = "Select * from Customer";

Northwind db = new Northwind(@"C:\Data\Northwnd.mdf");

LINQ facilita la depuración debido a su integración en el lenguaje C #.

LINQ - Configuración del entorno

Obtener Visual Studio 2010 instalado en Windows 7

1.6 GHz o más

Escribir el programa C # usando LINQ en Visual Studio 2010

Aparecerá un nuevo cuadro de diálogo del proyecto en su pantalla.

Dé un nombre a su proyecto en el cuadro de nombre inferior y presione OK.

El nuevo proyecto aparecerá en el Explorador de soluciones en el lado derecho de un nuevo

Aquí puede comenzar a codificar su siguiente programa C #.

Presione la tecla F5 y ejecute su proyecto. Se recomienda guardar el proyecto seleccionando

Escribir un programa VB usando LINQ en Visual Studio 2010

Aparecerá un nuevo cuadro de diálogo del proyecto en su pantalla.

Dé un nombre a su proyecto en el cuadro de nombre inferior y presione OK.

Presione la tecla F5 y ejecute su proyecto. Se recomienda guardar el proyecto seleccionando

Cuando el código anterior de C # o VB se agrupa y ejecuta, produce el siguiente resultado:

LINQ - Operadores de consultas

Descripción C # Sintaxis de Sintaxis de expresión

dónde Filtrar valores basados en una función de dónde Dónde

OfType Filtrar valores en función de su capacidad No aplica No aplica

Únete a los operadores

Descripción C # Sintaxis de Sintaxis de expresión

Operador Descripción C # Sintaxis de Sintaxis de

Seleccionar El operador proyecta valores en función seleccionar Seleccionar

Seleccionar El operador proyecta las secuencias de Usar múltiples de Usar múltiples

Operador Descripción C # Sintaxis de Sintaxis de

OrderBy El operador ordena los valores en orden ordenar Ordenar por

Descripción C # Sintaxis de Sintaxis de expresión

Para Ejecute una operación de agrupación en No aplica No aplica

Operador Descripción C # Sintaxis de Sintaxis de

AsEnumerable Devuelve la entrada escrita como No aplica No aplica

AsQueryable Un (genérico) IEnumerable se convierte No aplica No aplica

OfType Filtra los valores en función de sus No aplica No aplica

ToArray Fuerza la ejecución de la consulta y No aplica No aplica

ToDictionary Sobre la base de una función de selector No aplica No aplica