LINQ - Guía rápida

Los desarrolladores de todo el mundo siempre han encontrado problemas al consultar datos debido a la falta de una ruta definida y a la necesidad de dominar varias tecnologías como SQL, Web Services, 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
      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 brevemente a continuación.

• LINQ to Objects
• LINQ a XML (XLINQ)
• LINQ a DataSet
• LINQ a SQL (DLINQ)
• LINQ para entidades

Aparte 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 suelen ser objetos que implementan interfaces genéricas IEnumerable <T> o IQueryable <T>. La arquitectura se muestra a continuación.

Expresiones de consulta

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 suelen empezar 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 están escritas 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 la fuente de datos, la definición de la expresión de la consulta y la ejecución de la consulta.

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Operators {
   class LINQQueryExpressions {
      static void Main() {
      
         // 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

Introducidos 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 objetos para realizar algunas operaciones de consulta precisas para extender una clase sin ser un miembro real de esa clase. Estos también pueden estar sobrecargados.

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 el procedimiento almacenado

Existe una serie 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 en tiempo de ejecución al ejecutar una consulta LINQ que en comparación con un procedimiento almacenado, ya que el primero tiene el 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 volver a escribir el código para diversos tipos de bases de datos.

• La implementación de una solución basada en LINQ es fácil y simple en comparación con la implementación de un conjunto de procedimientos almacenados.

Necesidad de LINQ

Antes de LINQ, era esencial aprender C #, SQL y varias API que unen ambas para formar una aplicación completa. Dado que, 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 utilizaron los desarrolladores al consultar datos antes de la llegada 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, de las líneas de código destacadas, la consulta se define solo por las dos últimas. Con LINQ, la misma consulta de datos se puede escribir en una forma codificada por colores legible como la siguiente que se menciona a continuación, también en muy menos 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 principal es su poderosa expresividad que permite a los desarrolladores expresarse de forma declarativa. Algunas de las otras ventajas de LINQ se detallan 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 con facilidad.

• 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 característica jerárquica y esto permite redactar consultas uniendo múltiples tablas en menos tiempo.

• LINQ permite el uso de una sola sintaxis LINQ al consultar 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, además de dividir problemas complejos en un conjunto de consultas breves fáciles de depurar.

• LINQ ofrece una fácil transformación para la conversión de un tipo de datos a otro, como transformar datos SQL en datos XML.

Antes de comenzar con los programas LINQ, es mejor comprender primero los matices de la configuración de 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 por medio de 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 correctamente. 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 imprescindibles 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

Step 1 - Primero, después de insertar el DVD con Visual Studio 2010 Package, haga clic en Install or run program from your media que aparece en un cuadro emergente en la pantalla.

Step 2- Aparecerá en la pantalla ahora configurado para Visual Studio. EscogerInstall Microsoft Visual Studio 2010.

Step 3- Tan pronto como haga clic, se iniciará el proceso y aparecerá una ventana de configuración en su pantalla. Una vez completada la carga de los componentes de instalación, que llevará algún tiempo, haga clic enNext para pasar al siguiente paso.

Step 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 Next botón.

Step 5- Ahora seleccione las funciones para instalar desde la página de opciones que aparece en su pantalla. Puedes elegirFull o Customopción. Si tiene menos espacio en disco del requerido que se muestra en los requisitos de espacio en disco, elija Personalizado.

Step 6- Cuando elija la opción Personalizada, aparecerá la siguiente ventana. Seleccione las funciones que desea instalar y haga clic enUpdate o bien vaya al paso 7. Sin embargo, se recomienda no optar por la opción personalizada, ya que en el futuro, es posible que necesite las funciones que ha elegido no tener.

Step 7- Pronto se mostrará una ventana emergente y comenzará la instalación, lo que puede llevar mucho tiempo. Recuerde, esto es para instalar todos los componentes.

Step 8- Finalmente, podrá ver un mensaje en una ventana de que la instalación se ha completado con éxito. Hacer clicFinish.

Escritura del 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 cuadro de diálogo de nuevo proyecto en su pantalla.

• Ahora elija Visual C # como categoría en las plantillas instaladas y luego elija la plantilla Aplicación de consola como se muestra en la figura siguiente.

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

• 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 desde el Explorador de soluciones y puede ver el código en la ventana del editor que comienza con 'using System'.

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

using System;
using System.Collections.Generic;
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. Es muy recomendable guardar el proyecto eligiendoFile → Save All antes de ejecutar el proyecto.

Escritura del 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 cuadro de diálogo de nuevo proyecto en su pantalla.

• Ahora elija Visual Basic como categoría debajo de las plantillas instaladas y luego elija la plantilla Aplicación de consola.

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

• 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. Es muy recomendable guardar el proyecto eligiendoFile → Save All antes de ejecutar el proyecto.

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

Hello World

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
• Unirse a los operadores
• Operaciones de proyección
• Operadores de clasificación
• Operadores de agrupación
• Conversions
• Concatenation
• Aggregation
• Operaciones cuantificadoras
• Operaciones de partición
• Operaciones de generación
• Establecer operaciones
• Equality
• 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

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
dónde	Filtrar valores basados ​​en una función de predicado	dónde	Dónde
OfType	Filtrar valores según su capacidad para ser como un tipo específico	No aplica	No aplica

Unirse a los operadores

Unirse se refiere a una operación en la que se apuntan fuentes de datos con relaciones difíciles de seguir entre sí de manera directa.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Unirse	El operador une dos secuencias sobre la base de claves coincidentes	unirse ... en ... en ... es igual a ...	Desde x In…, y In… Donde xa = ya
GrupoUnirse	Une dos secuencias y agrupa los elementos coincidentes	unirse ... en ... en ... es igual a ... en ...	Unirse al grupo ... En ... El ...

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	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Seleccione	El operador proyecta valores sobre la base de una función de transformación	Seleccione	Seleccione
Seleccionar muchos	El operador proyecta las secuencias de valores que se basan en una función de transformación y las aplana en una sola secuencia.	Usar múltiples cláusulas from	Usar múltiples cláusulas From

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

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
OrderBy	El operador ordena los valores en orden ascendente	ordenar por	Ordenar por
OrderByDescending	El operador ordena los valores en orden descendente	orden por ... descendente	Ordenar por ... Descendente
Entonces por	Ejecuta una clasificación secundaria en orden ascendente	orderby…,…	Ordenar por…,…
ThenByDescending	Ejecuta una clasificación secundaria en orden descendente	orden por…,… descendiendo	Ordenar por…,… Descendente
Contrarrestar	Realiza una inversión del orden de los elementos en una colección.	No aplica	No aplica

Operadores de agrupación

Los operadores colocan los datos en algunos grupos basándose en un atributo compartido común.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Agrupar por	Organizar una secuencia de elementos en grupos y devolverlos como una colección IEnumerable de tipo IGrouping <clave, elemento>	agrupar ... por -o- grupo ... por ... en ...	Agrupar ... Por ... En ...
Para buscar	Ejecutar una operación de agrupación en la que se devuelve una secuencia de pares de claves	No aplica	No aplica

Conversiones

Los operadores cambian el tipo de objetos de entrada y se utilizan en una amplia gama de aplicaciones.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
AsEnumerable	Devuelve la entrada escrita como IEnumerable <T>	No aplica	No aplica
AsQueryable	Un IEnumerable (genérico) se convierte en un IQueryable (genérico)	No aplica	No aplica
Emitir	Realiza la conversión de elementos de una colección a un tipo específico	Utilice una variable de rango escrita explícitamente. Por ejemplo: de la cadena str en palabras	De ... Como ...
OfType	Filtra los valores en función de su, dependiendo de su capacidad para convertirse en un tipo particular	No aplica	No aplica
ToArray	Fuerza la ejecución de la consulta y hace la conversión de una colección a una matriz	No aplica	No aplica
ToDictionary	Sobre la base de una función de selector de teclas, configure los elementos en un Dictionary <TKey, TValue> y fuerce la ejecución de una consulta LINQ	No aplica	No aplica
Listar	Fuerza la ejecución de una consulta convirtiendo una colección en una List <T>	No aplica	No aplica
Para buscar	Fuerza la ejecución de una consulta y coloca elementos en una búsqueda <TKey, TElement> sobre la base de una función de selector de teclas	No aplica	No aplica

Concatenación

Realiza la concatenación de dos secuencias y es bastante similar al operador de la Unión en términos de su funcionamiento, excepto por el hecho de que no elimina los duplicados.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Concat	Se concatenan dos secuencias para la formación de una sola secuencia.	No aplica	No aplica

Agregación

Realiza cualquier tipo de agregación deseada y permite crear agregaciones personalizadas en LINQ.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Agregar	Opera sobre los valores de una colección para realizar una operación de agregación personalizada	No aplica	No aplica
Promedio	Se calcula el valor medio de una colección de valores	No aplica	Agregado ... en ... en promedio ()
Contar	Cuenta los elementos que satisfacen una función de predicado dentro de la colección	No aplica	Agregado ... en ... en recuento ()
LonCount	Cuenta los elementos que satisfacen una función de predicado dentro de una gran colección	No aplica	Agregado ... en ... en LongCount ()
Max	Descubra el valor máximo dentro de una colección	No aplica	Agregado ... en ... en Max ()
Min	Descubra el valor mínimo existente dentro de una colección	No aplica	Agregado… en… en min ()
Suma	Descubra la suma de valores dentro de una colección	No aplica	Agregado ... en ... en suma ()

Operaciones cuantificadoras

Estos operadores devuelven un valor booleano, es decir, verdadero o falso cuando algunos o todos los elementos de una secuencia satisfacen una condición específica.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Todas	Devuelve un valor 'Verdadero' si todos los elementos de una secuencia satisfacen una condición de predicado	No aplica	Agregar ... en ... en todos (...)
Ninguna	Determina al buscar en una secuencia si algún elemento de la misma satisface una condición especificada	No aplica	Agregar ... en ... en cualquier ()
Contiene	Devuelve un valor 'Verdadero' si encuentra que un elemento específico está en una secuencia si la secuencia no contiene ese elemento específico, se devuelve un valor 'falso'	No aplica	No aplica

Operadores de partición

Divida una secuencia de entrada en dos secciones separadas sin reorganizar los elementos de la secuencia y luego devolver uno de ellos.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Omitir	Omite un número específico de elementos dentro de una secuencia y devuelve los restantes	No aplica	Omitir
SkipWhile	Igual que el de Skip con la única excepción de que el número de elementos para omitir se especifica mediante una condición booleana	No aplica	Saltar mientras
Tomar	Tome un número específico de elementos de una secuencia y omita los restantes	No aplica	Tomar
TakeWhile	Igual que el de Take excepto el hecho de que el número de elementos a tomar se especifica mediante una condición booleana	No aplica	Tómese un tiempo

Operaciones de generación

Los operadores generacionales crean una nueva secuencia de valores.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
DefaultIfEmpty	Cuando se aplica a una secuencia vacía, genera un elemento predeterminado dentro de una secuencia	No aplica	No aplica
Vacío	Devuelve una secuencia de valores vacía y es el operador generacional más simple	No aplica	No aplica
Rango	Genera una colección que tiene una secuencia de enteros o números.	No aplica	No aplica
Repetir	Genera una secuencia que contiene valores repetidos de una longitud específica.	No aplica	No aplica

Establecer operaciones

Hay cuatro operadores para las operaciones establecidas, cada uno de los cuales produce un resultado basado en diferentes criterios.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
Distinto	Da como resultado una lista de valores únicos de una colección mediante el filtrado de datos duplicados, si los hay	No aplica	Distinto
Excepto	Compara los valores de dos colecciones y devuelve los de una colección que no están en la otra colección	No aplica	No aplica
Intersecarse	Devuelve el conjunto de valores encontrados t ser idénticos en dos colecciones separadas	No aplica	No aplica
Unión	Combina el contenido de dos colecciones diferentes en una sola lista que también sin ningún contenido duplicado	No aplica	No aplica

Igualdad

Compara dos oraciones (enumerables) y determina si coinciden exactamente o no.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
SequenceEqual	Da como resultado un valor booleano si se encuentra que dos secuencias son idénticas entre sí	No aplica	No aplica

Operadores de elementos

Excepto DefaultIfEmpty, los ocho operadores de elementos de consulta estándar restantes devuelven un solo elemento de una colección.

Mostrar ejemplos

Operador	Descripción	Sintaxis de expresión de consulta de C #	Sintaxis de expresión de consulta de VB
ElementAt	Devuelve un elemento presente dentro de un índice específico en una colección.	No aplica	No aplica
ElementAtOrDefault	Igual que ElementAt excepto por el hecho de que también devuelve un valor predeterminado en caso de que el índice específico esté fuera de rango	No aplica	No aplica
primero	Recupera el primer elemento dentro de una colección o el primer elemento que cumple una condición específica	No aplica	No aplica
Primero o predeterminado	Igual que Primero, excepto el hecho de que también devuelve un valor predeterminado en caso de que no existan dichos elementos	No aplica	No aplica
Último	Recupera el último elemento presente en una colección o el último elemento que cumple una condición específica	No aplica	No aplica
LastOrDefault	Igual que Last, excepto el hecho de que también devuelve un valor predeterminado en caso de que no exista ningún elemento de este tipo.	No aplica	No aplica
Soltero	Devuelve el único elemento de una colección o el único elemento que cumple una determinada condición.	No aplica	No aplica
SingleOrDefault	Igual que Single, excepto que también devuelve un valor predeterminado si no existe ningún elemento solitario.	No aplica	No aplica
DefaultIfEmpty	Devuelve un valor predeterminado si la colección o lista está vacía o es nula	No aplica	No aplica

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 realiza hábilmente la traducción de consultas integradas en el lenguaje del modelo de objetos a SQL. A continuación, estas consultas se envían a la base de datos para su ejecución. Después de obtener los resultados de la base de datos, LINQ to SQL los traduce nuevamente 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 el uso de expresiones LINQ habituales. También permite actualizar, borrar 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 la reducción de la complejidad, 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 utilizar LINQ to SQL?

Step 1- Realizar una nueva "Conexión de datos" con el servidor de base de datos. Ver & arrar; Explorador de servidores & arrar; Conexiones de datos & arrar; Agregar conexión

Step 2 - Agregar LINQ al archivo de clase SQL

Step 3 - Seleccione tablas de la base de datos y arrastre y suelte en el nuevo archivo de clase LINQ to SQL.

Step 4 - Tablas agregadas al archivo de la clase.

Consultando 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 de forma 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.

• LINQ to SQL API - solicita la ejecución de la consulta en nombre de una aplicación y la envía a LINQ to SQL Provider.

• LINQ to SQL Provider - convierte la consulta en Transact SQL (T-SQL) y envía la nueva consulta al proveedor de ADO para su ejecución.

• ADO Provider - 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 lo 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 {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);           

         //Create new Employee
		 
         Employee newEmployee = new Employee();
         newEmployee.Name = "Michael";
         newEmployee.Email = "[email protected]";
         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}, Address = {4}",
                          insertedEmployee.EmployeeId, insertedEmployee.Name, insertedEmployee.Email, 
                          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("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim newEmployee As New Employee()
	  
      newEmployee.Name = "Michael"
      newEmployee.Email = "[email protected]"
      newEmployee.ContactNo = "343434343"
      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("Michael"))

      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

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

Emplyee ID = 4, Name = Michael, Email = [email protected], ContactNo = 
343434343, Address = Michael - USA

Press any key to continue.

Actualizar

C#

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         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 = "[email protected]";
         employee.ContactNo = "99999999";
         employee.DepartmentId = 2;
         employee.Address = "Michael George - UK";

         //Save changes to Database.
         db.SubmitChanges();

         //Get Updated Employee            
         Employee updatedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael"));

         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Address = {4}",
                          updatedEmployee.EmployeeId, updatedEmployee.Name, updatedEmployee.Email, 
                          updatedEmployee.ContactNo, updatedEmployee.Address);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Module Module1

   Sub Main()
  
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim employee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"))

      employee.Name = "George Michael"
      employee.Email = "[email protected]"
      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("George Michael"))

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

      Console.WriteLine(vbLf & "Press any key to continue.")
      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 = [email protected], ContactNo = 
999999999, Address = Michael George - UK

Press any key to continue.

Eliminar

C#

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         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);

         //Save changes to Database.
         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.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Module Module1

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim deleteEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("George Michael"))

      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.WriteLine(vbLf & "Press any key to continue.")
      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 = 1, Name = William, Email = [email protected], ContactNo = 999999999
Emplyee ID = 2, Name = Miley, Email = [email protected], ContactNo = 999999999
Emplyee ID = 3, Name = Benjamin, Email = [email protected], ContactNo = 

Press any key to continue.

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 to Objects

Las consultas en LINQ to Objects devuelven variables de tipo normalmente solo IEnumerable <T>. En resumen, LINQ to Objects ofrece un enfoque nuevo para las colecciones como antes, era vital escribir codificación larga (bucles foreach de mucha complejidad) para la recuperación de datos de una colección que ahora se reemplaza por la escritura de código declarativo que describe claramente los datos deseados. que se requiere para recuperar.

También hay muchas ventajas de LINQ to Objects sobre los bucles foreach tradicionales, como más legibilidad, filtrado potente, capacidad de agrupación, ordenación mejorada con codificación mínima de aplicaciones. Estas consultas LINQ también son de naturaleza más compacta y se pueden transferir 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.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQtoObjects {
   class Program {
      static void Main(string[] args) {
      
         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 usa como la colección de objetos que se consultarán usando LINQ to Objects.

Objects query is:
var list = from t in tools select t;

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

Tablesaw
Bandsaw
Planer
Jointer
Drill
Sander

Consulta en colecciones de memoria mediante LINQ to Objects

C#

using System;
using System.Collections.Generic;
using System.Linq;

namespace LINQtoObjects {
   class Department {
      public int DepartmentId { get; set; }
      public string Name { get; set; }
   }

   class LinqToObjects {
      static void Main(string[] args) {
      
         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.WriteLine("\nPress any key to continue.");
         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() {account, sales, marketing})

      Dim departmentList = From d In departments

      For Each dept In departmentList
         Console.WriteLine("Department Id = {0} , Department Name = {1}", dept.DepartmentId, dept.Name)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Class Department
      Public Property Name As String
      Public Property DepartmentId As Integer
   End Class
   
End Module

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

Department Id = 1, Department Name = Account
Department Id = 2, Department Name = Sales
Department Id = 3, Department Name = Marketing

Press any key to continue.

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 sin complicaciones y mejora la productividad.

Introducción de LINQ al conjunto de datos

LINQ to Dataset ha simplificado la tarea de realizar consultas 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 utilizar para consultar dónde se consolidan los datos de varias fuentes de datos. Esto tampoco necesita ningún proveedor 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 la cláusula de unión. Finalmente, foreach loop se utiliza para mostrar los resultados deseados.

C#

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LINQtoDataset {
   class Program {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         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.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      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").Columns("DepartmentId"), ds.Tables("Employee").Columns("DepartmentId"))

      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") Equals
                  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")
                  }

      For Each e In query
         Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}", e.EmployeeId, e.EmployeeName, e.DepartmentName)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
  
   Class Person
      Public Property EmployeeId As Integer
      Public Property EmployeeName As String
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

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

Employee Id = 1, Name = William, Department Name = Account
Employee Id = 2, Name = Benjamin, Department Name = Account
Employee Id = 3, Name = Miley, Department Name = Sales

Press any key to continue.

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 datos en un conjunto de datos y esto se hace usando la clase DataAdapter o LINQ to SQL. La formulación de consultas mediante LINQ to Dataset es bastante similar a la formulación de consultas mediante 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 luego el ID del pedido, la fecha del pedido y el número de pedido se muestran como salida.

C#

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LinqToDataset {
   class SingleTable {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         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.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim sqlSelect As String = "SELECT * FROM Department;"
      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")
      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.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Public Class DepartmentDetail
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

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

Department Id = 1, Name = Account
Department Id = 2, Name = Sales
Department Id = 3, Name = Pre-Sales
Department Id = 4, Name = Marketing

Press any key to continue.

LINQ to XML ofrece fácil acceso 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, tipificación segura y muchos más 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 en disco documentos XML existentes en la memoria 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. Tiene las 19 clases necesarias para trabajar con XML. Estas clases son las siguientes.

• XAttribute
• XCData
• XComment
• XContainer
• XDeclaration
• 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.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         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.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      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.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

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

Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing

Press any key to continue.

Agregar nuevo nodo

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         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);

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

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

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      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)

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

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

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

Department Name - Support
Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

Eliminar nodo particular

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Support</Department>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       <Department>Finance</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

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

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
     	                   "<Department>Support</Department>" & vbCr & vbLf & 
     	                   "<Department>Account</Department>" & vbCr & vbLf & 
     	                   "<Department>Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Marketing</Department>" & vbCr & vbLf & 
     	                   "<Department>Finance</Department>" & vbCr & vbLf & 
                           "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)
     
      xdoc.Descendants().Where(Function(s) s.Value = "Sales").Remove()

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

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

Department Name - Support
Department Name - Account
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

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 soporte importante de ASP.Net en el sentido de que los usuarios pueden hacer uso de un control de fuente de datos para ejecutar una consulta a través de LINQ to Entities y facilita la vinculación de los resultados sin necesidad de codificación adicional.

Por 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 realizar una actualización por lotes fácilmente. El hecho más intrigante sobre LINQ to Entities es que tiene la misma sintaxis que 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 un ObjectQuery instancia de una ObjectContext (Conexión de entidad)

• Redactar una consulta en C # o Visual Basic (VB) usando la instancia recién construida

• Conversión de operadores de consulta estándar de LINQ, así como expresiones LINQ en árboles de comandos

• Ejecutar la consulta pasando las excepciones encontradas al cliente directamente

• Devolver al cliente todos los resultados de la consulta

ObjectContext es aquí la clase principal que permite la interacción con Entity Data Modelo en otras palabras actúa como un puente que conecta LINQ a la base de datos. Los árboles de comandos son aquí representación de consultas con compatibilidad con Entity framework.

Entity Framework, por otro lado, es en realidad Object Relational Mapperabreviado generalmente como ORM por los desarrolladores que hace la generación de objetos de negocio así como entidades según las tablas de la base de datos y facilita varias operaciones básicas como crear, actualizar, borrar y leer. La siguiente ilustración muestra el marco de la entidad y sus componentes.

Ejemplo de ADD, UPDATE y DELETE usando LINQ con Entity Model

Primero agregue el modelo de entidad siguiendo los pasos a continuación.

Step 1- Haga clic con el botón derecho en el proyecto y haga clic en Agregar nuevo elemento para abrir una ventana como se muestra a continuación. Seleccione Modelo de datos de entidad ADO.NET, especifique el nombre y haga clic en Agregar.

Step 2 - Seleccionar Generate from database.

Step 3 - Elija Conexión a la base de datos en el menú desplegable.

Step 4 - Seleccionar todas las tablas.

Ahora escribe el siguiente código.

using DataAccess;
using System;
using System.Linq;

namespace LINQTOSQLConsoleApp {
   public class LinqToEntityModel {
      static void Main(string[] args) {

         using (LinqToSQLDBEntities context = new LinqToSQLDBEntities()) {
            //Get the List of Departments from Database
            var departmentList = from d in context.Departments
            select d;

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

            //Add new 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.DepartmentId == 1);
            updateDepartment.Name = "Account updated";
            context.SaveChanges();

            Console.WriteLine("Department Name = Account is updated in Database");

            //Delete existing Department
            DataAccess.Department deleteDepartment = context.Departments.FirstOrDefault(d ⇒d.DepartmentId == 3);
            context.Departments.Remove(deleteDepartment);
            context.SaveChanges();

            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;

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

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

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

El término 'expresión lambda' ha derivado 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 LINQ traducen la lógica de una manera en el tiempo de ejecución para que pueda pasar a la fuente de datos de manera conveniente. Sin embargo, las expresiones lambda no se limitan a encontrar 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 se eleva al cuadrado. Sin embargo, no es posible ejecutar una expresión lambda en esta forma. A continuación se muestra un ejemplo de una expresión lambda en C #.

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   class Program {

      delegate int del(int i);
      static void Main(string[] args) {

         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
   
   Sub Main(ByVal args As String())
   
      Dim myDelegate As del = Function(y) y * y
      Dim j As Integer = myDelegate(5)
      Console.WriteLine(j)
      Console.ReadLine()
	  
   End Sub
   
End Module

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

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 conocen como expresión lambda.

Lambdas asíncronas

La expresión lambda creada mediante la incorporación de procesamiento asincrónico mediante el uso de la palabra clave async se conoce como lambdas asíncronas. A continuación se muestra un ejemplo de lambda asíncrono.

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 a pedido y trabaja continuamente en cada uno de los elementos de la secuencia de entrada y no en toda la secuencia. La expresión Lambda permite a los desarrolladores introducir su propia lógica en los operadores de consulta estándar. En el siguiente ejemplo, el desarrollador ha utilizado el operador 'Dónde' para recuperar los valores impares de la lista dada haciendo uso de una expresión lambda.

C#

//Get the average of the odd Fibonacci numbers in the series... 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   class Program {     
      static void Main(string[] args) {
      
         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

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

7.33333333333333

Inferencia de tipos 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 funcionará solo cuando se haya especificado cada tipo, ya que el compilador debe cumplirse. Consideremos el siguiente ejemplo.

delegate int Transformer (int i);

Aquí el compilador emplea la inferencia de tipos para basarse en el hecho de que x es un número entero y esto se hace examinando el tipo de parámetro del Transformer.

Alcance variable en expresión Lambda

Existen algunas reglas al usar el alcance de la variable en una expresión lambda, como las variables que se inician dentro de una expresión lambda no están destinadas a ser visibles en un método externo. También existe una regla de que una variable capturada no debe ser recolectada como basura a menos que el delegado que hace referencia a la misma sea elegible para el acto de recolección de basura. Además, existe una regla que prohíbe una declaración de devolución dentro de una expresión lambda para provocar la devolución de un método adjunto.

A continuación, se muestra un ejemplo para demostrar el alcance de la variable en una expresión lambda.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   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);
         }

         static void Main() {
            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();
         }
      }
   }
}

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

j = 0
j = 10. b = True
True

Árbol de expresión

Las expresiones lambda se utilizan en Expression Treeconstrucción extensamente. 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 un 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 statement lambdasconsta de dos o tres declaraciones, pero no se utilizan en la construcción de árboles de expresión. Una declaración de retorno debe escribirse en una instrucción lambda.

Sintaxis de la instrucción lambda

(params)⇒ {statements}

Ejemplo de una instrucción lambda

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace lambdaexample {
   class Program {
      static void Main(string[] args) {
         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();
      }
   }
}

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

3
8
1
7
9
2
8

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 operadores como is o asal igual que los métodos anónimos. Aunque las expresiones Lambda son métodos anónimos muy parecidos, estos no están restringidos en absoluto para usarse 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 formas 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 expresión lambda mediante una función conocida como cierre. El uso del cierre debe realizarse con precaución para evitar cualquier problema.

• Es imposible ejecutar un código inseguro dentro de cualquier expresión lambda.

• Las expresiones lambda no están diseñadas para usarse en el lado izquierdo del operador.

Como 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 con la creación de un sitio web ASP.NET que haga uso de las características de LINQ.

Para esto, es esencial tener instalado 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 siguiente figura.

Ahora, debajo de las plantillas en el lado izquierdo, habrá dos opciones de idioma para crear el sitio web. EscogerVisual C# y seleccione ASP.NET Empty Web Site.

Seleccione la carpeta donde desea guardar el nuevo sitio web en su sistema. Entonces presioneOK y así Solution Exploreraparece en su pantalla que contiene todos los archivos web. Haga clic con el botón derecho en Default.aspx en el Explorador de soluciones y elija Ver en el navegador para ver el sitio web ASP.NET predeterminado en el navegador. Pronto se abrirá su nuevo sitio web ASP.NET en el navegador web, como se muestra en la siguiente captura de pantalla.

.aspx es, de hecho, la principal extensión de archivo utilizada en los sitios web ASP.NET. Visual Studio crea de forma predeterminada todas las páginas necesarias para un sitio web básico comoHome page y About Uspágina donde puede colocar su contenido cómodamente. El código del sitio web se genera automáticamente aquí y también se puede ver.

Control de LINQDataSource

Es posible UPDATE, INSERT y DELETEdatos en las páginas del sitio web ASP.NET con la ayuda del control LINQDataSource. No hay absolutamente ninguna necesidad de especificar comandos SQL ya que el control LINQDataSource emplea comandos creados dinámicamente para tales operaciones.

El control permite al usuario hacer uso de LINQ en una página web ASP.NET convenientemente mediante la configuración de propiedades en el texto de marcado. LINQDataSource es muy similar al de controles comoSqlDataSource tanto como ObjectDataSourceya que se puede utilizar para vincular otros controles ASP.NET presentes en una página a una fuente de datos. Entonces, debemos tener undatabase para explicar las diversas funciones invocadas por el control LINQDataSource.

Antes de comenzar la explicación del 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 en la página .aspx del sitio web ASP.NET como se muestra en la figura siguiente.

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 siguiente figura. El control GridView es poderoso 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 = "Title" />
                  <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 da 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 rigurosamente todos los pasos anteriores, elija el LINQDataSource Tasks desde el LINQDataSource Control y elija las tres casillas para habilitar insertar, habilitar actualización y habilitar eliminar del mismo, 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 de detalles o Control maestro debajo del control Vista de cuadrícula para mostrar solo los detalles de una fila seleccionada de la cuadrícula. Elija Tareas de vista de detalles en el control Vista de detalles y seleccione las casillas de verificación como se muestra a continuación.

Ahora, simplemente guarde los cambios y presione Ctrl + F5 para ver la página en su navegador donde ahora es posible eliminar, actualizar, insertar cualquier registro en el control de vista de detalles.