Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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#.
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.
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.
El uso de una expresión Lambda en la programación de aplicaciones modernas encuentra una variedad de casos de uso, incluyendo:
Task.Run
, se pueden utilizar expresiones lambda para definir la operación asíncrona a ejecutar.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.
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))
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.
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 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
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.
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#.!
9 productos API .NET para sus documentos de oficina