Expressions Lambda en C# (Comment ça marche pour les développeurs)

Introduction

Dans le domaine de la programmation C#, les expressions lambda constituent l'une des fonctionnalités les plus puissantes. Ces constructions concises et expressives permettent aux développeurs d'écrire un code compact mais robuste, améliorant ainsi la lisibilité, la maintenabilité et l'efficacité globale.

Dans cet article, nous allons nous plonger dans les expressions lambda de C#, en explorant leur syntaxe, leurs cas d'utilisation, leurs avantages et leurs 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 des applications C#.

Comprendre les expressions Lambda

Les expressions lambda, introduites dans C# 3.0, offrent un moyen succinct de définir des fonctions anonymes ou des délégués. Il s'agit essentiellement de fonctions anonymes en ligne qui peuvent être utilisées partout où un type de délégué est attendu.

La syntaxe d'une expression lambda est la suivante :

(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

Ici, les paramètres sont les paramètres d'entrée de l'expression lambda, et l'expression est la déclaration ou le bloc de déclarations à exécuter. Le moteur d'exécution du langage commun .NET crée une fonction anonyme pour chaque expression lambda lors de la compilation.

Utilisation de base

Examinons un exemple d'expression Lambda dans lequel nous avons une liste d'entiers et nous voulons filtrer les nombres pairs.

Nous pouvons réaliser cela 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 % 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)

Dans l'exemple ci-dessus, x => x % 3 == 0 est une expression lambda qui prend un entier x comme paramètre d'entrée et renvoie vrai si x est pair, et faux autrement. L'expression du corps lambda est exécutée sur chaque élément du tableau.

Cas d'utilisation

L'utilisation d'une expression Lambda dans la programmation d'applications modernes trouve une variété de cas d'utilisation, y compris :

1. Requêtes LINQ : Les expressions lambda sont largement utilisées dans LINQ (Language Integrated Query) pour effectuer des opérations de filtrage, de projection, de tri et de regroupement sur des collections de données.

2. Gestion d'événements : Lorsque l'on travaille avec des événements et des délégués, les expressions lambda offrent un moyen concis de définir des gestionnaires d'événements en ligne.

3. Programmation asynchrone : Dans des modèles de programmation asynchrone tels que Task.Run, des expressions lambda peuvent être utilisées pour définir l'opération asynchrone à exécuter.

4. Programmation fonctionnelle : Les expressions lambda prennent en charge les paradigmes de programmation fonctionnelle, permettant des opérations telles que map, filter et reduce sur des collections.

Types d'expressions Lambda

Lambdas d'expression

Les expressions lambda avec => sont appelées lambdas d'expression. Ils se présentent sous la forme suivante :

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

Dans l'exemple ci-dessus, nous créons le carré d'un nombre. Dans les lambdas d'expression, le corps peut inclure des appels de méthode. Toutefois, lors de la génération d'arbres d'expressions destinés à être évalués en dehors du .NET Common Language Runtime (CLR), comme dans SQL Server, il est conseillé d'éviter tout appel de méthode au sein des expressions lambda.

En effet, les méthodes peuvent ne pas avoir de sens en dehors du contexte du CLR. Il est donc essentiel de tenir compte de l'environnement cible lors de la construction d'un arbre d'expression afin d'en assurer la compatibilité et l'interprétation pertinente.

Déclaration Lambdas

Le code ci-dessous montre comment déclarer des expressions lambda. Ici, on déclare d'abord un délégué qui possède une méthode avec seulement des paramètres et un corps.

Ensuite, lorsque c'est nécessaire, un nom de fonction/méthode est ajouté au paramètre du délégué.

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))

Techniques avancées

Capturer les variables

Les expressions lambda peuvent capturer des variables de la portée qui les entoure. Cette fonctionnalité, connue sous le nom de capture de variable ou de fermeture, permet aux expressions lambda d'accéder à des variables déclarées en dehors de leur corps et de les utiliser.

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

Dans cet exemple, l'expression lambda x => x * factor capture la variable factor de la portée environnante.

Paramètres et déclarations multiples

Les expressions lambda peuvent avoir plus d'un paramètre et exécuter plusieurs instructions 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;
};

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 une bibliothèque PDF d'Iron Software

Explorez IronPDF en tant que bibliothèque de génération et d'analyse PDF polyvalente et performante de Iron Software qui peut être utilisée pour générer des documents PDF.

IronPDF peut être installé à partir du gestionnaire de paquets NuGet avec la commande ci-dessous :

Install-Package IronPdf

Ou installé à partir de Visual Studio comme indiqué ci-dessous :

Nous allons maintenant nous intéresser à la génération de PDF à l'aide d'une expression 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

Sortie

Licence d'essai

Le code IronPDF peut fonctionner uniquement avec une licence d'essai obtenue depuis la page de licence d'essai IronPDF. Fournissez un identifiant e-mail dans la fenêtre pop-up pour générer une clé de licence et l'envoyer à votre adresse e-mail.

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

Placez la clé de licence dans le fichier AppSettings.Json.

Conclusion

Les expressions lambda C# offrent un moyen concis et expressif de définir des fonctions en ligne, ce qui rend le code plus lisible, plus facile à maintenir et plus efficace. Ils trouvent des applications dans divers domaines, notamment 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 atteindre 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 débutiez votre parcours, comprendre et exploiter la puissance des expressions lambda élèvera sans aucun doute vos compétences en programmation vers de nouveaux sommets.

Alors plongez, expérimentez et embrassez la beauté des expressions lambda dans vos projets C# !