C# Language
Expressions lambda

Remarques

Passer une expression Lambda en tant que paramètre à une méthode

List<int> l2 = l1.FindAll(x => x > 6);

Ici x => x > 6 est une expression lambda agissant comme un prédicat qui garantit que seuls les éléments supérieurs à 6 sont renvoyés.

Expressions Lambda comme raccourci pour l'initialisation des délégués

public delegate int ModifyInt(int input);
ModifyInt multiplyByTwo = x => x * 2;

La syntaxe d'expression Lambda ci-dessus est équivalente au code explicite suivant:

public delegate int ModifyInt(int input);

ModifyInt multiplyByTwo = delegate(int x){
    return x * 2;
};

Lambdas pour `Func` et` Action`

Les lambdas sont généralement utilisés pour définir des fonctions simples (généralement dans le contexte d’une expression linq):

var incremented = myEnumerable.Select(x => x + 1);

Ici, le return est implicite.

Cependant, il est également possible de passer des actions en tant que lambdas:

myObservable.Do(x => Console.WriteLine(x));

Expressions lambda avec plusieurs paramètres ou aucun paramètre

Utilisez des parenthèses autour de l'expression à gauche de l'opérateur => pour indiquer plusieurs paramètres.

delegate int ModifyInt(int input1, int input2);
ModifyInt multiplyTwoInts = (x,y) => x * y;

De même, un ensemble vide de parenthèses indique que la fonction n'accepte pas les paramètres.

delegate string ReturnString();
ReturnString getGreeting = () => "Hello world.";

Mettre plusieurs instructions dans une déclaration Lambda

Contrairement à une expression lambda, une instruction lambda peut contenir plusieurs instructions séparées par des points-virgules.

delegate void ModifyInt(int input);

ModifyInt addOneAndTellMe = x =>
{
    int result = x + 1;
    Console.WriteLine(result);
};

Notez que les instructions sont placées entre accolades {} .

N'oubliez pas que l'instruction lambdas ne peut pas être utilisée pour créer des arborescences d'expression.

Les Lambdas peuvent être émises à la fois comme `Func` et` Expression`

En supposant la classe Person suivante:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Le lambda suivant:

p => p.Age > 18

Peut être passé en argument aux deux méthodes:

public void AsFunc(Func<Person, bool> func)
public void AsExpression(Expression<Func<Person, bool>> expr)

Parce que le compilateur est capable de transformer des lambdas à la fois en délégués et en Expression s.

De toute évidence, les fournisseurs LINQ s'appuient fortement sur les Expression (exposées principalement via l'interface IQueryable<T> ) pour pouvoir analyser les requêtes et les traduire en magasin.

Expression Lambda en tant que gestionnaire d'événements

Les expressions Lambda peuvent être utilisées pour gérer des événements, ce qui est utile lorsque:

• Le gestionnaire est court.
• Le gestionnaire n'a jamais besoin d'être désabonné.

Une bonne situation dans laquelle un gestionnaire d'événements lambda peut être utilisé est donnée ci-dessous:

smtpClient.SendCompleted += (sender, args) => Console.WriteLine("Email sent");

Si le désabonnement d'un gestionnaire d'événement enregistré à un moment ultérieur du code est nécessaire, l'expression du gestionnaire d'événement doit être enregistrée dans une variable et l'inscription / désinscription doit être effectuée via cette variable:

EventHandler handler = (sender, args) => Console.WriteLine("Email sent");

smtpClient.SendCompleted += handler;
smtpClient.SendCompleted -= handler;

La raison pour laquelle cela est fait plutôt que de simplement ressaisir l'expression lambda textuellement pour la désabonner ( -= ) est que le compilateur C # ne considérera pas nécessairement les deux expressions égales:

EventHandler handlerA = (sender, args) => Console.WriteLine("Email sent");
EventHandler handlerB = (sender, args) => Console.WriteLine("Email sent");
Console.WriteLine(handlerA.Equals(handlerB)); // May return "False"

Notez que si des instructions supplémentaires sont ajoutées à l'expression lambda, les accolades environnantes requises peuvent être accidentellement omises, sans provoquer d'erreur de compilation. Par exemple:

smtpClient.SendCompleted += (sender, args) => Console.WriteLine("Email sent"); emailSendButton.Enabled = true;

Cela compilera, mais entraînera l'ajout de l'expression lambda (sender, args) => Console.WriteLine("Email sent"); en tant que gestionnaire d'événements et en exécutant l'instruction emailSendButton.Enabled = true; immédiatement. Pour corriger cela, le contenu du lambda doit être entouré d'accolades. Cela peut être évité en utilisant des accolades dès le début, en étant prudent lors de l'ajout d'instructions supplémentaires à un gestionnaire d'événements lambda, ou en entourant le lambda entre parenthèses dès le début:

smtpClient.SendCompleted += ((sender, args) => Console.WriteLine("Email sent"));
//Adding an extra statement will result in a compile-time error