Expresión lambda en declaraciones LINQ en C#

1. LINQ en C#
2. Sintaxis de LINQ en C#
3. Expresiones Lambda en C#
4. Expresión lambda en LINQ

Este sencillo artículo trata sobre las expresiones lambda en las consultas Select de LINQ. Para eso, primero analizaremos una breve introducción a LINQ, sus sintaxis y expresiones Lambda.

Además, explicaremos cómo podemos usar expresiones lambda en las consultas Select de LINQ.

LINQ en C#

LINQ es un acrónimo de Language Integrated Query. Es un formato uniforme para consultar los datos de múltiples fuentes de datos como objetos, XML, servidores de datos SQL, conjuntos de datos, etc.

El único requisito para esa fuente de datos es que implemente la interfaz IEnumerable<T> .

LINQ proporciona múltiples ventajas:

1. LINQ ofrece consultas basadas en objetos e integradas en el lenguaje sin importar dónde se originaron los datos. Por lo tanto, podemos consultar bases de datos, XML y colecciones usando LINQ.
2. Comprobación de la sintaxis en tiempo de compilación.
3. Le permite consultar colecciones, como arreglos, clases enumerables, etc., en el idioma nativo de su aplicación, como VB o C#, como si consultara una base de datos usando SQL.

Considere un escenario en el que tenemos una lista de números y debemos seleccionar números menores que 10. Luego, la consulta LINQ puede ayudarnos a elegir los datos.

Veamos el segmento de código a continuación:

using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApp6 {
  class Program {
    static void Main(string[] args) {
      List<int> listOfNumbers = new List<int>() { 16, 11, 2, 5, 9, 8, 7, 6, 1, 12 };
      var result = from l in listOfNumbers
          where l<10 select l;
      foreach (int i in result) Console.WriteLine(i);
    }
  }
}

Puede ver en la consulta LINQ anterior que esto es similar a la sintaxis de consulta que usamos para consultar datos de bases de datos SQL. Aquí, estamos consultando datos de un miembro de datos local Lista.

La salida del segmento de código será:

Sintaxis de LINQ en C#

Hay dos sintaxis de LINQ que se utilizan al programar con LINQ:

1. Sintaxis de consulta
2. Sintaxis del método

Sintaxis de consulta en LINQ

La sintaxis de consulta de LINQ comprende un conjunto de palabras clave de consulta definidas en la versión 3.5 o superior de .NET Framework. Esto permite a los programadores o desarrolladores escribir comandos de estilo SQL en código (C# o VB.NET) sin usar comillas.

También se conoce como la sintaxis de expresión de consulta.

La palabra clave from inicia la sintaxis de consulta LINQ y termina con la palabra clave Select o GroupBy. Siguiendo la palabra clave, puede usar varias operaciones de consulta estándar, como filtrado, agrupación, etc., para satisfacer sus necesidades.

El siguiente ejemplo utiliza la sintaxis de consulta para obtener los datos de la lista:

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

class LinqExample {
  static public void Main() {
    List<string> myList = new List<string>() { "Cat", "Dog", "Tiger", "Wolf" };

    // Create LINQ Query
    var result = from a in myList select a;

    // Executing the query
    foreach (var r in result) {
      Console.WriteLine(r);
    }
  }
}

Esto generará la siguiente salida:

Sintaxis del método en LINQ

La sintaxis de métodos se usa en LINQ para invocar los métodos de extensión de las clases estáticas Enumerable o Queryable. También se conoce como sintaxis de extensión de método.

El compilador, por otro lado, siempre convierte la sintaxis de consulta en sintaxis de método en tiempo de compilación. Puede utilizar operadores de consulta estándar como Seleccionar, Dónde, Agrupar por, Unirse, Max, etc.

Puede llamarlos directamente sin usar la sintaxis de consulta.

En el siguiente ejemplo, usaremos la sintaxis del método para obtener el nombre de un animal cuya longitud de nombre sea mayor que 3. La consulta se formará así:

var result = myList.Where(a => a.Length > 3);

El código completo para la sintaxis del método será así:

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

class LinqExample {
  static public void Main() {
    List<string> myList = new List<string>() { "Cat", "Dog", "Tiger", "Wolf" };

    // Create LINQ Query
    var result = myList.Where(a => a.Length > 3);

    // Executing the query
    foreach (var r in result) {
      Console.WriteLine(r);
    }
  }
}

Esto dará el siguiente resultado:

En la sintaxis del método, puede notar una expresión en el argumento de la función Dónde que consiste en un signo =>. Esta cosa inusual se conoce como la expresión Lambda.

En la siguiente sección, analizaremos la expresión Lambda y su uso con consultas LINQ.

Expresiones Lambda en C#

En C#, las expresiones lambda se usan de manera similar a las funciones anónimas, con la excepción de que no tiene que especificar el tipo de valor que ingresa cuando usa una expresión lambda, lo que la hace más flexible.

Todas las expresiones lambda utilizan el operador lambda, representado por el símbolo =>. La entrada está en el lado izquierdo de la expresión lambda y la expresión está en el lado derecho.

Las expresiones lambda se clasifican en dos formas:

1. Expresión lambda
2. Declaración Lambda

expresión lambda

Esto comprende una declaración de entrada y una expresión que se evaluará a la derecha del símbolo lambda:

input statement => expression

Declaración lambda

Esto comprende una declaración de entrada y un conjunto de declaraciones en el lado derecho del símbolo lambda:

input statements => { set of statements }

Supongamos que tenemos una estructura de datos Lista que consta de algunos números y necesitamos evaluar el cubo de todos los números de la lista. Esto se puede hacer de manera muy simple usando la expresión lambda.

Esto se puede demostrar en el siguiente segmento de código:

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

namespace ConsoleApp6 {
  class Program {
    static void Main(string[] args) {
      List<int> listOfNumbers = new List<int>() { 16, 11, 2, 5, 9, 8, 7, 6, 1, 12 };
      var cubes = listOfNumbers.Select(a => a * a * a);

      // Display all the cubes
      Console.Write("Cubes of the List : ");
      foreach (var val in cubes) {
        Console.Write("{0} ", val);
      }
    }
  }
}

Puede ver en el segmento de código anterior que hemos seleccionado un elemento de la lista usando la función Seleccionar y luego hicimos su cubo usando la expresión lambda.

La salida del segmento será la siguiente:

Expresión lambda en LINQ

La expresión lambda y LINQ proporcionan una forma de consultar los datos de cualquier fuente de datos. Aquí hay algunos ejemplos en los que consultaremos datos usando la sintaxis Lambda de LINQ.

Supongamos que tenemos una clase definida por el usuario de Estudiante con roll_num, nombre y marcas como sus propiedades. Inicializaremos algunos datos en la lista de estudiantes y luego consultaremos los datos mediante consultas LINQ y expresiones lambda.

class Student {
  private int roll_num;
  private string name;
  private int marks;

  public int Roll_num {
    get => roll_num;
    set => roll_num = value;
  }
  public string Name {
    get => name;
    set => name = value;
  }
  public int Marks {
    get => marks;
    set => marks = value;
  }
}

En nuestra función Principal, crearemos una lista de clases de Estudiante y luego consultaremos los datos de ella:

static void Main(string[] args) {
  List<Student> students =
      new List<Student>() { new Student { Roll_num = 1, Name = "David", Marks = 65 },
                            new Student { Roll_num = 2, Name = "John", Marks = 90 },
                            new Student { Roll_num = 3, Name = "Dina", Marks = 87 },
                            new Student { Roll_num = 4, Name = "Leen", Marks = 43 },
                            new Student { Roll_num = 5, Name = "Krish", Marks = 57 } };
}

Después de crear la lista, supongamos que necesitamos seleccionar a los estudiantes con calificaciones superiores a 60 y mostrárselas al usuario. Para eso, usaremos expresiones lambda y consultas LINQ.

Console.WriteLine("Through Lambda Expression");
IEnumerable<Student> sortedData = students.Where(x => x.Marks > 60);
foreach (var s in sortedData) Console.WriteLine(s.Roll_num + "  " + s.Name + "  " + s.Marks);

Console.WriteLine("Through LINQ query");
IEnumerable<Student> result = from s in students
    where s.Marks> 60 select s; foreach (var s in sortedData) Console.WriteLine(s.Roll_num + "  " + s.Name + "  " + s.Marks);

Tenga en cuenta que en el segmento de código anterior, hemos seleccionado los mismos datos de 2 formas diferentes. Vea que a través de las declaraciones Lambda, consultar datos es muy simple y requiere menos codificación que las consultas LINQ.

La salida será la misma para ambos casos:

En el ejemplo anterior, mostramos todos los datos de los estudiantes. Si necesitamos obtener el nombre de los estudiantes que obtuvieron calificaciones superiores a 60, entonces la expresión lambda será:

var stuNames = students.Where(x => x.Marks > 60).Select(x => x.Name);
foreach (var s in stuNames) Console.WriteLine(s);

Esto devolverá solo los nombres de los estudiantes. Por lo tanto, no los hemos almacenado en un tipo IEnumerable.

La salida será:

Supongamos que queremos los nombres y las calificaciones de los estudiantes, pero primero debemos ordenarlos según sus calificaciones. Usaremos la función OrderBy para ordenar los datos.

var stuNames = students.OrderBy(x => x.Marks).Select(x => new { x.Name, x.Marks });
foreach (var s in stuNames) Console.WriteLine(s.Name + "  " + s.Marks);

La salida será:

Por lo tanto, podemos ver que diferentes métodos pueden consultar datos utilizando expresiones lambda. Las expresiones lambda son útiles cuando tiene una gran cantidad de datos y requiere pasos de codificación mínimos para consultar o aplicar varias operaciones a los datos.