Comment utiliser les expressions lambda en C #

Les expressions Lambda ont été introduites pour la première fois dans .NET 3.5, en même temps que la requête LINQ (Language Integrated Query) était disponible. Les expressions Lambda sont comme des méthodes anonymes mais avec beaucoup plus de flexibilité. Lorsque vous utilisez une expression lambda, vous n'avez pas besoin de spécifier le type de l'entrée. Par conséquent, une expression lambda fournit une manière plus courte et plus propre de représenter les méthodes anonymes.

Dans cet article, nous verrons comment nous pouvons utiliser les expressions lambda en C #. Pour utiliser les exemples de code fournis dans cet article, vous devez disposer de Visual Studio 2019 installé sur votre système. Si vous n'en avez pas déjà une copie, vous pouvez télécharger Visual Studio 2019 ici. 

Créer un projet d'application console dans Visual Studio

Tout d'abord, créons un projet d'application console .NET Core dans Visual Studio. En supposant que Visual Studio 2019 est installé sur votre système, suivez les étapes décrites ci-dessous pour créer un nouveau projet d'application console .NET Core dans Visual Studio.

  1. Lancez l'IDE de Visual Studio.
  2. Cliquez sur "Créer un nouveau projet".
  3. Dans la fenêtre «Créer un nouveau projet», sélectionnez «Application console (.NET Core)» dans la liste des modèles affichés.
  4. Cliquez sur Suivant. 
  5. Dans la fenêtre «Configurer votre nouveau projet» ci-dessous, spécifiez le nom et l'emplacement du nouveau projet.
  6. Cliquez sur Créer.

Suivre ces étapes devrait aboutir à un nouveau projet d'application console .NET Core dans Visual Studio 2019. Nous utiliserons ce projet pour travailler avec les expressions lambda C # dans les sections suivantes de cet article.

Anatomie d'une expression Lambda

Une expression lambda est essentiellement une méthode qui n'a pas de déclaration. En d'autres termes, une expression lambda est une méthode qui n'a pas de spécificateur d'accès ou de nom. Une expression lambda peut être divisée en deux sections: la partie gauche et la partie droite. La partie gauche est utilisée pour la saisie et la partie droite est utilisée pour écrire des expressions.

Voici la syntaxe pour utiliser les expressions lambda en C #.

(Paramètres d'entrée) => Expression ou bloc d'instructions

Vous pouvez avoir deux types d'expressions lambda, une expression lambda et une instruction lambda. Une expression lambda comprend une entrée sur le côté gauche et une expression sur le côté droit, comme indiqué ci-dessous.

entrée => expression;

Une instruction lambda est composée d'une entrée sur le côté gauche et d'un ensemble d'instructions sur le côté droit, comme illustré ci-dessous.

input => {instructions};

Exemples d'expressions Lambda en C #

L'écriture d'une expression lambda est simple - il vous suffit de supprimer le mot-clé délégué et le type de paramètre d'une méthode anonyme. Considérez la méthode anonyme suivante qui utilise le mot-clé délégué ainsi qu'un type de paramètre.

delegate (Author a) {retourne a.IsActive && a.NoOfBooksAuthored> 10; }

L'instruction ci-dessus peut être convertie en une expression lambda, comme indiqué dans l'extrait de code ci-dessous.

(a) => {a.IsActive && a.NoOfBooksAuthored> 10; }

Dans l'instruction ci-dessus se atrouve le paramètre et =>est l'opérateur lambda. La déclaration suivante est l'expression.

a.IsActive && a.NoOfBooksAuthored> 10;

Voici un autre exemple d'expression lambda qui affiche les nombres impairs entre 1 et 9 dans la fenêtre de la console.

Liste entiers = nouvelle liste {1, 2, 3, 4, 5, 6, 7, 8, 9};

foreach (entier num en entiers.Where (n => n% 2 == 1) .ToList ())

{

  Console.WriteLine (num);

}

Expressions lambda avec et sans paramètres

Les expressions Lambda peuvent être sans paramètre ou avoir un ou plusieurs paramètres. L'extrait de code suivant illustre une expression lambda qui n'a aucun paramètre.

() => Console.WriteLine ("Ceci est une expression lambda sans aucun paramètre");

Les expressions Lambda peuvent également avoir un ou plusieurs paramètres. L'extrait de code suivant illustre comment vous pouvez passer un paramètre à une expression lambda.

(a, numberOfBooksAuthored) => a.NoOfBooksAuthored> = numberOfBooksAuthored;

Vous pouvez également spécifier le type du paramètre dans une expression lambda, comme indiqué dans l'extrait de code ci-dessous.

(a, int numberOfBooksAuthored) => a.NoOfBooksAuthored> = numberOfBooksAuthored;

Vous pouvez même spécifier plusieurs instructions dans une expression lambda à l'aide d'accolades. Ceci est illustré dans l'extrait de code suivant. 

(a, 10) =>

{

   Console.WriteLine ("Ceci est un exemple d'expression lambda

                      avec plusieurs déclarations ");

   return a.NoOfBooksAuthored> = 10;

}

Déclaration lambdas en C #

Une instruction lambda utilise une syntaxe identique à l'expression lambdas. La différence est que, au lieu d'avoir une expression à droite de l'opérateur, l'instruction lambda a un bloc de code qui comprend une ou plusieurs instructions.

L'extrait de code suivant illustre comment vous pouvez tirer parti d'une instruction lambda pour afficher les nombres pairs entre 1 et 9 dans la fenêtre de la console.

int [] entiers = nouveau [] {1, 2, 3, 4, 5, 6, 7, 8, 9};

foreach (int i en entiers.Where (x =>

{

   si (x% 2 == 0)

         retourne vrai;

    retourner faux;

 }

 ))

Console.WriteLine (i);

Les expressions Lambda sont une fonctionnalité intéressante dans .NET et .NET Core qui fournissent un moyen plus court de représenter les méthodes anonymes. Les expressions Lambda peuvent avoir zéro paramètre ou un ou plusieurs. Vous pouvez même attribuer des expressions lambda aux délégués Func, Action ou Predicate. Dans un prochain article ici, nous explorerons ces fonctionnalités et d'autres des expressions lambda. Nous allons également explorer comment nous pouvons travailler avec les expressions lambda et LINQ ainsi que les lambdas async.

Comment faire plus en C #:

  • Quand utiliser une classe abstraite ou une interface en C #
  • Comment travailler avec AutoMapper en C #
  • Comment utiliser les expressions lambda en C #
  • Comment travailler avec les délégués Action, Func et Predicate en C #
  • Comment travailler avec des délégués en C #
  • Comment implémenter un simple logger en C #
  • Comment travailler avec des attributs en C #
  • Comment travailler avec log4net en C #
  • Comment implémenter le modèle de conception de référentiel en C #
  • Comment travailler avec la réflexion en C #
  • Comment travailler avec Filesystemwatcher en C #
  • Comment effectuer une initialisation différée en C #
  • Comment travailler avec MSMQ en C #
  • Comment travailler avec des méthodes d'extension en C #
  • Comment utiliser les expressions lambda en C #
  • Quand utiliser le mot clé volatile en C #
  • Comment utiliser le mot clé yield en C #
  • Comment implémenter le polymorphisme en C #
  • Comment créer votre propre planificateur de tâches en C #
  • Comment travailler avec RabbitMQ en C #
  • Comment travailler avec un tuple en C #
  • Explorer les méthodes virtuelles et abstraites en C #