Dans le domaine de la programmation C#, les expressions lambda se démarquent comme l'une des fonctionnalités les plus puissantes. Ces constructions concises et expressives permettent aux développeurs d'écrire du code compact mais robuste, améliorant ainsi la lisibilité, la maintenabilité et l'efficacité globale.
Dans cet article, nous allons plonger profondément dans les expressions lambda C#, en explorant leur syntaxe, cas d'utilisation, avantages et techniques avancées. Nous explorerons également comment les capacités d'IronPDF de Iron Software peuvent générer un document PDF à la volée dans les applications C#.
Les expressions lambda, introduites dans C# 3.0, offrent un moyen succinct de définir des fonctions anonymes ou des délégués. Ce sont essentiellement des fonctions anonymes en ligne qui peuvent être utilisées partout où un type délégué est attendu.
La syntaxe d'une expression lambda est :
(parameters) => expression // lambda expression syntax'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression ' lambda expression syntaxExemple :
x => x * x // lambda expression to square a number'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' lambda expression to square a numberIci, parameters sont les paramètres d'entrée de l'expression lambda, et expression est l'instruction ou le bloc d'instructions à exécuter. Le common language runtime de .NET crée une fonction anonyme pour chaque expression lambda au moment de la compilation.
Regardons un exemple d'expression lambda où nous avons une liste d'entiers, et nous voulons filtrer les nombres pairs.
Nous pouvons y parvenir en utilisant la méthode List<t>.FindAll avec une expression lambda :
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 2 == 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 2 = 0)Dans l'exemple ci-dessus, x => x % 2 == 0 est une expression lambda qui prend un entier x comme paramètre d'entrée et retourne true si x est pair, et false sinon. L'expression du corps de la lambda est exécutée sur chaque élément de la liste.
L'utilisation d'une expression Lambda dans la programmation d'applications modernes trouve une variété de cas d'utilisation, y compris :
Task.Run, les expressions lambda peuvent être utilisées pour définir l'opération asynchrone à exécuter.Les expressions lambda avec => sont appelées lambdas d'expression. Elles prennent le format :
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 numberDans l'exemple ci-dessus, nous créons un carré d'un nombre. Dans les expressions lambdas, le corps peut inclure des appels de méthode. Cependant, lors de la génération d'arbres d'expressions destinés à être évalués en dehors du Common Language Runtime .NET (CLR), comme dans SQL Server, il est conseillé d'éviter tout appel de méthode dans les expressions lambda.
Ceci est dû au fait que les méthodes peuvent manquer de signification en dehors du contexte CLR. Il est donc crucial de prendre en compte l'environnement cible lors de la construction d'un arbre d'expression pour assurer une compatibilité et une interprétation significative.
Les expressions lambda déclaratives permettent plusieurs instructions et fournissent des opérations plus complexes :
Func<int, int> mySquareDelegate = (x) =>
{
return x * x;
};
Console.WriteLine(mySquareDelegate(4)); // Output: 16Dim mySquareDelegate As Func(Of Integer, Integer) = Function(x)
Return x * x
End Function
Console.WriteLine(mySquareDelegate(4)) ' Output: 16Dans ce code, un délégué est déclaré qui opère sur des entiers et renvoie leur carré. Le corps de la lambda peut englober plusieurs instructions dans un bloc {}.
Les expressions lambda peuvent capturer des variables de l'environnement englobant. Cette fonctionnalité, connue sous le nom de capture de variable ou fermeture, permet aux expressions lambda d'accéder et d'utiliser des variables déclarées en dehors de leur corps :
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 * factorDans cet exemple, l'expression lambda x => x * factor capture la variable factor de l'étendue environnante.
Les expressions lambda peuvent avoir plus d'un paramètre et exécuter plusieurs instructions encloses dans un bloc :
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 FunctionExplorez IronPDF comme une bibliothèque de génération et d'analyse de PDF polyvalente et haute performance d'Iron Software qui peut être utilisée pour générer des documents PDF.
IronPDF peut être installé depuis le gestionnaire de packages NuGet avec la commande ci-dessous :
Ou installé depuis Visual Studio comme indiqué ci-dessous :
Passons maintenant à la génération de PDF en utilisant une expression lambda :
using IronPdf; // Import the IronPdf library
using System;
using System.Collections.Generic;
using System.Linq;
namespace IronPatterns
{
class Program
{
static void Main()
{
Console.WriteLine("-----------Iron Software-------------");
var renderer = new ChromePdfRenderer(); // Initialize the PDF renderer
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 };
// Use Select to create a list of squared numbers
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); // Render the HTML as a PDF
pdf.SaveAs("output.pdf"); // Save the PDF document
}
}
}Imports IronPdf ' Import the IronPdf library
Imports System
Imports System.Collections.Generic
Imports System.Linq
Namespace IronPatterns
Friend Class Program
Shared Sub Main()
Console.WriteLine("-----------Iron Software-------------")
Dim renderer = New ChromePdfRenderer() ' Initialize the PDF renderer
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}
' Use Select to create a list of squared numbers
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) ' Render the HTML as a PDF
pdf.SaveAs("output.pdf") ' Save the PDF document
End Sub
End Class
End Namespace
Le code IronPDF ne peut fonctionner qu'avec une licence d'essai obtenue depuis la page de licence d'essai IronPDF. Fournissez un identifiant Email dans la fenêtre contextuelle pour générer une clé de licence et envoyez cette clé à votre email.
"IronPdf.LicenseKey": "<YourKey>"Placez la clé de licence dans le fichier AppSettings.json.
Les expressions lambda C# offrent un moyen concis et expressif de définir des fonctions en ligne, rendant le code plus lisible, maintenable et efficace. Elles trouvent des applications dans divers domaines, y compris les requêtes LINQ, la gestion des événements, la programmation asynchrone et la programmation fonctionnelle.
En maîtrisant les expressions lambda, les développeurs peuvent débloquer de nouvelles dimensions de productivité et d'élégance dans leurs bases de code C#.
Que vous soyez un développeur C# chevronné ou que vous commenciez tout juste votre parcours, comprendre et exploiter la puissance des expressions lambda élèvera sans aucun doute vos compétences en programmation à de nouveaux sommets.
Alors plongez, expérimentez, et embrassez la beauté des expressions lambda dans vos projets C#!
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
