logotipo
icono menu

Lenguage Integrated Query

¿Qúe es LINQ y que beneficios aporta a mis desarollos?

Por Esteban GaRo

3/6/2018

Garo NET

Sitio de documentación de las principales técnologías de desarrollo .NET

LINQ es el acrónimo de Language Integrated Query (consultas integradas en el lenguaje) y representa una tecnología de consulta de datos del .NET Framework a través de la cual podemos definir "expresiones de consultas" contra una gran variedad de "conjuntos de datos", que pueden ser desde colecciones de objetos en memoria, documentos XML hasta bases de datos relaciones o cualquier origen que podamos imaginar (documentos excel, directorios, etc, eso sí para estos casos habría que echar mano de extensiones de terceros, pero de que se puede, se puede!), utilizando una misma "sintaxis de consulta" sin importar la naturaleza del origen de datos subyacente.

¿Cuáles son las ventajas de incluir LINQ en nuestros desarrollos?

Contar con verificación de errores e IntelliSense durante la definición de nuestras "expresiones de consultas", pues al estar "incrustadas" en el código fuente debemos cumplir con las reglas de sintaxis del lenguaje de programación, en este caso Visual C#.
Olvidar el uso de ciclos, bucles y otras técnicas de iteración para realizar operaciones de ordenamiento, selección, agrupación, transformación, entre otras, sobre un conjunto de datos determinado.
La sintaxis de LINQ es muy elegante y al ser muy parecida a la sintaxis SQL resulta sumamente sencillo interpretar una consulta sin tener completo conocimiento de la sintaxis.
Si dominas la sintaxis LINQ to Objects te resultará muy sencillo trabajar con el resto de implementaciones disponibles en el .NET Framework; LINQ to Dataset, LINQ to XML, LINQ to SQL y LINQ to Entities.
El grupo de operadores de consulta estándar de LINQ to Objects se podría considerar como la base de operadores de consulta que el resto de implementaciones LINQ deberán implementar como mínimo (sean implementaciones del .NET Framework o personalizadas).

¿A qué se le conoce como "expresiones de consultas"?

Nos referimos a "expresiones de consultas" a todas aquellas expresiones dentro del código fuente de la aplicación que hagan uso de los operadores LINQ disponibles por "implementación" (nos referimos como "implementación" a todas aquellas variantes de LINQ incluidas en el .NET Framework como LINQ to Objects, LINQ to Dataset, LINQ to XML, LINQ to SQL y LINQ to Entities) para la definición de consultas contra un origen de datos determinado.

Existen 2 formas de crear "expresiones de consultas LINQ" la primera de ellas es mediante la extensión a la sintaxis del lenguaje a través del uso de palabras clave como "from", "where", "orderby", "select", etc lo que también se le conoce como "azúcar sintáctico", pues de cierta forma "endulza" el código fuente dando un significado mas cercano a lo que representa la expresión, en este caso representar una consulta ocupando una sintaxis muy parecida a la de SQL, la segunda forma consiste en realizar invocaciones "directas" a métodos disponibles en el tipo IEnumerable<E> / IQueryable<E>

¿Cuáles son las principales características que dan soporte a LINQ?

Tipos anónimos inmutables (declaración de variables "var" y creación de objetos anónimos).
Métodos de extensión (Todos los operadores LINQ se encuentran implementados como métodos de extensión para el tipo IEnumerable<E> a través de la clase auxiliar Enumerable/Queryable
Métodos anónimos (Sintaxis tradicional o expresiones lambda para definir delegados requeridos por los operadores LINQ).

Ejemplos prácticos

Los siguientes ejemplos de código fuente se pueden ejecutar como proyectos de aplicación de consola (.NET Framework).

Exp Consulta LINQ.cs, presenta las diferencias entre las 2 formas posibles para crear "expresiones de consulta" con LINQ.
LINQ vs FOR.cs, presenta la ventaja del uso de LINQ contra el uso de bloques de iteración.
Sintaxis Exp Consulta LINQ.cs
LINQ vs FOR.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace LINQ_0
{
    public class DefinicionExpresionesConsultaLINQ
    {

        //Por: Esteban GaRo 03/2018.
        //@estebangaro

        //El siguiente ejemplo práctico consiste en conocer las 2 formas de crear expresiones de consulta
        //utilizando la extensión a la sintaxis del lenguaje (y el conjunto de operadores de consulta estándar) o bien
        //utilizando la invocación de métodos (de extensión) del tipo IEnumerable<E>/IQueryable<E>.

        public static void Main(string[] args)
        {
            IEnumerable<string> Resultado = LINQ_ExtensionAlLenguaje();
            Console.WriteLine("Resultado de consulta definiendo expresión de consulta utilizando " +
                "la extensión a la sintaxis del lenguaje.");
            MuestraConsulta(Resultado);
            Resultado = LINQ_InvocacionDeMetodos();
            Console.WriteLine("Resultado de consulta definiendo expresión de consulta utilizando " +
                "invocación de métodos.");
            MuestraConsulta(Resultado);

            Console.Read();
        }

        private static IEnumerable<string> LINQ_ExtensionAlLenguaje()
        {
            string[] NombresPersonas = { "Esteban", "Ámbar", "Dalia", "Fernando", "Victor" };

            IEnumerable<string> NombresOrdenados = from nombre in NombresPersonas
                                                   orderby nombre ascending
                                                   select nombre.ToUpper();

            return NombresOrdenados;
        }

        private static IEnumerable<string> LINQ_InvocacionDeMetodos()
        {
            string[] NombresPersonas = { "Esteban", "Ámbar", "Dalia", "Fernando", "Victor" };

            IEnumerable<string> NombresOrdenados = NombresPersonas
                .OrderBy(nombre => nombre)
                .Select(nombre => nombre.ToUpper());

            return NombresOrdenados;
        }

        private static void MuestraConsulta(IEnumerable Resultado)
        {
            foreach(var elemento in Resultado)
            {
                Console.WriteLine(elemento);
            }
        }
    }
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace LINQ_0
{
    public class EjemploPractico_LINQ
    {
        
        //Por: Esteban GaRo 03/2018.
        //@estebangaro
        
        //El siguiente ejemplo práctico consiste en obtener los primeros 3 nombres cuya cadena inicial coincida con "E"
        //presentandolo ordenados por órden alfabético y en caractéres mayúsuculas.
        //Como se podrá apreciar utilizando LINQ to Objects resulta mucho mas fácil, sencillo y legible que utilizando un algoritmo
        //basado en ciclos de iteración y tipos de colección.

        public static void Main(string[] args)
        {
            CompareLINQVSForLoopIterate("E", 3);
            Console.Read();
        }

        private static IEnumerable GetThreeFirstNamesWith_LINQ(string String, IEnumerable<string> Names,
            int NumberOfOcurrences)
        {
            IEnumerable Resultado = (from name in Names
                                     where name.StartsWith(String)
                                     orderby name ascending
                                     select name.ToUpper()).Take(NumberOfOcurrences);

            return Resultado;
        }

        private static IEnumerable GetThreeFirstNamesWith_For(string String, IEnumerable<string> Names,
            int NumberOfOcurrences)
        {
            string[] NamesArray = Names.ToArray();
            string Temp;
            // Se implementa el algoritmo de ordenamiento de la burbuja.
            for(int i = 0; i < NamesArray.Length - 1; i++)
                for(int j = i + 1; j < NamesArray.Length; j++)
                    if(NamesArray[i].CompareTo(NamesArray[j]) > 0)
                    {
                        Temp = NamesArray[j];
                        NamesArray[j] = NamesArray[i];
                        NamesArray[i] = Temp;
                    }
            // Se filtran los 3 primeros nombres que comiencen con la cadena especificada.
            List<string> NamesStartWithList = new List<string>();
            for (int i = 0; i < NamesArray.Length; i++)
                if (NamesArray[i].StartsWith(String) && NamesStartWithList.Count < NumberOfOcurrences)
                    NamesStartWithList.Add(NamesArray[i].ToUpper());

            return NamesStartWithList;
        }

        public static void CompareLINQVSForLoopIterate(string String, int NumberOfOcurrences)
        {
            string[] NamesOfPersons = { "Esteban", "Ernesto", "Dalia", "Fernando", "Eduardo", "Dante", "Daniela",
                "Francisco", "Ámbar", "Enrique"};

            IEnumerable Res_LINQ = GetThreeFirstNamesWith_LINQ(String, NamesOfPersons, NumberOfOcurrences);
            IEnumerable Res_FOR = GetThreeFirstNamesWith_For(String, NamesOfPersons, NumberOfOcurrences);

            Console.WriteLine($"Primeros {NumberOfOcurrences} nombres que inician con '{String}' " +
                $"ordenados alfabeticamente (LINQ)");
            int index = 0;
            foreach(var result in Res_LINQ)
            {
                Console.WriteLine($"{index++}) {result}");
            }
            Console.WriteLine($"Primeros {NumberOfOcurrences} nombres que inician con '{String}' " +
                $"ordenados alfabeticamente (FOR)");
            index = 0;
            foreach (var result in Res_FOR)
            {
                Console.WriteLine($"{index++}) {result}");
            }
        }
    }
}

Puedes conocer más de LINQ en los siguentes enlaces:

Flecha ocultar Mostrar comentario
responder Responder
Responder
Avatar cliente
Publicar
Mostrar Más

Artículos Relacionados

Salir
Resultado de búsqueda

Artículo Descripción
¿Quién Soy?
Habilidades
Experiencia
Contactame

Luis Esteban cuenta con mas de 2 años de experiencia en el desarrollo de software con el .NET Framework de Microsoft, estudió la carrera de Ingeniería en Comunicaciones y Electrónica en la ESIME Unidad Culhuacán del IPN eligiendo la especialidad de Computación en 8vo y 9no semestre.

Se encuentra en constante documentación sobre nuevos frameworks y tecnologías de desarrollo .NET, con el objetivo de elegir las mejores herramientas disponibles acorde a las necesidades de los proyectos, asegurando el mejor rendimiento y respuesta de los mismos.

Frameworks .NET ASP .NET Web Forms
ASP .NET MVC
ASP .NET WEB API
Windows Forms
Entity Framework
LINQ
Tecnologías WEB HTML 5
CSS3
JavaScript
jQuery
BDs SQL SERVER 2008-2014
Oracle XE 11G
MYSQL

Financiera Contigo (Contigo)

  • 05/2017 - 02/2018 (9 meses)
  • Desarrollador .NET Jr
  • Actividades destacadas
    • Diseño, desarrollo, implementación y mantenimiento en aplicaciones WEB (WEB FORMS).
    • Diseño, desarrollo e implementación en aplicaciones para escritorio de windows (Windows Forms).
    • Diseño, desarrollo e implementación en Servicios WEB ASP .NET.
    • Elaboración de documentación (requerimientos, documentación de código fuente, etc).

TasiSoftware (tasisfot)

  • 01/2016 - 05/2017 (1 año 5 meses)
  • Desarrollador .NET Jr
  • Actividades destacadas
    • Diseño, desarrollo, implementación y mantenimiento de aplicaciones WEB (WEB FORMS - MVC).
    • Diseño, desarrollo e implementación de aplicaciones para escritorio de windows (Windows Forms).
    • Diseño, desarrollo e implementación de servicios windows.
    • Elaboración de documentación (requerimientos, documentación de código fuente, etc).
Enviar
Presentación
Tecnologías empleadas

gaRo NET

La gaRo NET es un sitio web de documentación de los principales Frameworks y APIs del Microsoft .NET Framework, de fácil lectura e implementación gracias a los ejemplos de código acompañados en cada artículo enfocados a requerimientos de aplicaciones en proyectos reales.

¿Porqué existe la gaRo NET?

Para poder referirse a la documentación a la hora de utilizar alguna API o Framework en algún proyecto o bien para fines de estudio, contribuir con mejoras a los contenidos y que llegue a existir una retroalimentación entre los usuarios y autores.