C# Lambda Expressions (Cómo funciona para desarrolladores)

Introducción

En el ámbito de la programación en C#, las expresiones lambda se erigen como una de las características más potentes. Estas construcciones concisas y expresivas permiten a los desarrolladores escribir código compacto pero robusto, mejorando la legibilidad, la capacidad de mantenimiento y la eficiencia general.

En este artículo, profundizaremos en las expresiones lambda de C#, explorando su sintaxis, casos de uso, ventajas y técnicas avanzadas. También exploraremos cómo IronPDF de Iron Software puede generar un documento PDF sobre la marcha en aplicaciones C#.

Expresiones lambda

Las expresiones lambda, introducidas en C# 3.0, proporcionan una forma sucinta de definir funciones anónimas o delegadas. Se trata básicamente de funciones anónimas en línea que pueden utilizarse siempre que se espere un tipo de delegado.

La sintaxis de una expresión lambda es:

(parameters) => expression // lambda operator oe method syntax
x=> x*x // expression to square a number

(parameters) => expression // lambda operator oe method syntax
x=> x*x // expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression x=> x*x ' expression to square a number

Aquí, parameters son los parámetros de entrada de la expresión lambda, y expression es la sentencia o bloque de sentencias a ejecutar. El tiempo de ejecución del lenguaje común .NET crea una función anónima para cada expresión lambda durante el tiempo de compilación.

Uso básico

Veamos un ejemplo de expresión lambda en el que tenemos una lista de números enteros y queremos filtrar los números pares.

Podemos conseguirlo utilizando la función List<T>.FindAll junto con una expresión lambda:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 3 == 0);

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 3 == 0);

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Dim evenNumbers As List(Of Integer) = numbers.FindAll(Function(x) x Mod 3 = 0)

En el ejemplo anterior, x => x % 3 == 0 es una expresión lambda que toma un número entero x como parámetro de entrada y devuelve verdadero si x es par, y falso en caso contrario. El cuerpo de la expresión lambda se ejecuta en cada elemento del array.

Casos prácticos

El uso de una expresión Lambda en la programación de aplicaciones modernas encuentra una variedad de casos de uso, incluyendo:

1. Consultas LINQ: Las expresiones lambda se utilizan ampliamente en LINQ (Idioma Consulta integrada) para realizar operaciones de filtrado, proyección, ordenación y agrupación de colecciones de datos.
2. Manejo de eventos: Cuando se trabaja con eventos y delegados, las expresiones lambda proporcionan una forma concisa de definir manejadores de eventos en línea.
3. Programación asíncrona: En patrones de programación asíncrona como Task.Run, se pueden utilizar expresiones lambda para definir la operación asíncrona a ejecutar.
4. Programación funcional: Las expresiones lambda soportan paradigmas de programación funcional, permitiendo operaciones como map, filter y reduce sobre colecciones.

Tipos de expresiones lambda

Lambdas de expresión

Las expresiones lambda con => se denominan expresiones lambda. Tienen el siguiente formato:

x=> x*x // expression to square a number

x=> x*x // expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x=> x*x ' expression to square a number

En el ejemplo anterior, estamos creando el cuadrado de un número. En las lambdas de expresión, el cuerpo puede incluir llamadas a métodos. Sin embargo, al generar árboles de expresiones destinados a ser evaluados fuera de .NET Common Language Runtime (CLR)como en SQL Server, es aconsejable evitar cualquier llamada a métodos dentro de expresiones lambda.

Esto se debe a que los métodos pueden carecer de significado fuera del contexto del CLR. Por lo tanto, es crucial tener en cuenta el entorno de destino al construir un árbol de expresiones para garantizar la compatibilidad y una interpretación significativa.

Lambdas de declaración

El siguiente código muestra cómo declarar expresiones lambda. Aquí se declara primero un delegado que tiene un método con sólo parámetros y cuerpo.

A continuación, cuando es necesario, se añade un nombre de función/método al parámetro delegado.

Func<int> mySquareDelegate = (x =>
{
    return x*x;
});
Console.WriteLine(mySquareDelegate(4));

Func<int> mySquareDelegate = (x =>
{
    return x*x;
});
Console.WriteLine(mySquareDelegate(4));

Dim mySquareDelegate As Func(Of Integer) = (Function(x)
	Return x*x
End Function)
Console.WriteLine(mySquareDelegate(4))

Técnicas avanzadas

Captura de variables

Las expresiones lambda pueden capturar variables del ámbito circundante. Esta característica, conocida como captura o cierre de variables, permite a las expresiones lambda acceder y utilizar variables declaradas fuera de su cuerpo.

int factor = 2;
Func<int, int> multiplier = x => x * factor;

int factor = 2;
Func<int, int> multiplier = x => x * factor;

Dim factor As Integer = 2
Dim multiplier As Func(Of Integer, Integer) = Function(x) x * factor

En este ejemplo, la expresión lambda x => x * factor captura la variable factor del ámbito adjunto.

Parámetros y sentencias múltiples

Las expresiones lambda pueden tener más de un parámetro y ejecutar varias sentencias encerradas en un bloque.

Func<int, int, int> add = (a, b) => 
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Func<int, int, int> add = (a, b) => 
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Dim add As Func(Of Integer, Integer, Integer) = Function(a, b)
	Dim result As Integer = a + b
	Console.WriteLine($"The sum of {a} and {b} is {result}")
	Return result
End Function

IronPDF, una biblioteca PDF de Iron Software

IronPDF es una biblioteca de generación y análisis sintáctico de PDF versátil y de alto rendimiento de Iron Software que puede utilizarse para generar documentos PDF.

IronPDF puede instalarse desde el gestor de paquetes NuGet con el siguiente comando:

Install-Package IronPdf

O instalado desde Visual Studio como se muestra a continuación:

Ahora vamos a sumergirnos en la generación de PDF utilizando una expresión lambda.

namespace IronPatterns;
class Program
{
    static void Main()
    {
        Console.WriteLine("-----------Iron Software-------------");
        var renderer = new ChromePdfRenderer(); // var pattern
        var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";
        content += "<h2>Demo C# lambda expressions</h2>";
        content += $"<p>Generating Square of list of numbers x=>x*x</p>";
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        List<int> squares = numbers.Select(x => x * x).ToList();
        content += $"<p>Numbers list: {string.Join(",",numbers)}</p>";
        content += $"<p>Squares: {string.Join(",",squares)}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF
    }
}

namespace IronPatterns;
class Program
{
    static void Main()
    {
        Console.WriteLine("-----------Iron Software-------------");
        var renderer = new ChromePdfRenderer(); // var pattern
        var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";
        content += "<h2>Demo C# lambda expressions</h2>";
        content += $"<p>Generating Square of list of numbers x=>x*x</p>";
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        List<int> squares = numbers.Select(x => x * x).ToList();
        content += $"<p>Numbers list: {string.Join(",",numbers)}</p>";
        content += $"<p>Squares: {string.Join(",",squares)}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF
    }
}

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' var pattern
			Dim content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!"
			content &= "<h2>Demo C# lambda expressions</h2>"
			content &= $"<p>Generating Square of list of numbers x=>x*x</p>"
			Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			Dim squares As List(Of Integer) = numbers.Select(Function(x) x * x).ToList()
			content &= $"<p>Numbers list: {String.Join(",",numbers)}</p>"
			content &= $"<p>Squares: {String.Join(",",squares)}</p>"
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub
	End Class
End Namespace

Salida

Licencia de prueba

El código IronPDF sólo puede ejecutarse con una licencia de prueba obtenida en aquí. Proporcione un ID de correo electrónico en la ventana emergente para generar una clave de licencia y enviársela a su correo electrónico.

"IronPDF.LicenseKey": "<Your Key>"

Coloque la clave de licencia en el archivo AppSettings.Json.

Conclusión

Las expresiones lambda de C# ofrecen una forma concisa y expresiva de definir funciones en línea, lo que hace que el código sea más legible, fácil de mantener y eficiente. Tienen aplicaciones en diversos ámbitos, como las consultas LINQ, la gestión de eventos, la programación asíncrona y la programación funcional.

Al dominar las expresiones lambda, los desarrolladores pueden desbloquear nuevas dimensiones de productividad y elegancia en sus bases de código C#.

Tanto si eres un desarrollador experimentado de C# como si acabas de iniciar tu andadura, comprender y aprovechar el poder de las expresiones lambda sin duda elevará tus habilidades de programación a nuevas cotas.

Así que sumérgete, experimenta y disfruta de la belleza de las expresiones lambda en tus proyectos de C#.!