C# Language
Lambda-uitdrukkingen

Opmerkingen

Een Lambda-expressie als parameter doorgeven aan een methode

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

Hier is x => x > 6 een lambda-expressie die fungeert als een predikaat dat ervoor zorgt dat alleen elementen boven 6 worden geretourneerd.

Lambda-uitdrukkingen als steno voor initialisatie van gedelegeerden

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

De bovenstaande syntaxis van de Lambda-expressie is gelijk aan de volgende uitgebreide code:

public delegate int ModifyInt(int input);

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

Lambdas voor zowel `Func` als` Action`

Typisch worden lambdas gebruikt voor het definiëren van eenvoudige functies (meestal in de context van een linq-expressie):

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

Hier is de return impliciet.

Het is echter ook mogelijk om acties uit te voeren als lambdas:

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

Lambda-uitdrukkingen met meerdere parameters of geen parameters

Gebruik haakjes rond de uitdrukking links van de operator => om meerdere parameters aan te geven.

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

Evenzo geeft een lege reeks haakjes aan dat de functie geen parameters accepteert.

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

Zet meerdere verklaringen in een verklaring Lambda

In tegenstelling tot een lambda-expressie kan een lambda-instructie meerdere instructies bevatten gescheiden door puntkomma's.

delegate void ModifyInt(int input);

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

Merk op dat de uitspraken tussen accolades staan {} .

Onthoud dat statement lambdas niet kan worden gebruikt om expressiebomen te maken.

Lambdas kan zowel als `Func` als` Expression` worden uitgezonden

Uitgaande van de volgende Person class:

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

De volgende lambda:

p => p.Age > 18

Kan als argument aan beide methoden worden doorgegeven:

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

Omdat de compiler in staat is lambdas zowel naar afgevaardigden als Expression s te transformeren.

Het is duidelijk dat LINQ-providers sterk afhankelijk zijn van Expression s (voornamelijk blootgesteld via de IQueryable<T> -interface) om query's te kunnen parseren en te vertalen naar query's.

Lambda-expressie als event-handler

Lambda-expressies kunnen worden gebruikt om gebeurtenissen af te handelen, wat handig is wanneer:

• De handler is kort.
• De handler hoeft zich nooit af te melden.

Hieronder wordt een goede situatie gegeven waarin een lambda-event handler zou kunnen worden gebruikt:

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

Als het op een bepaald moment in de code uitschrijven van een geregistreerde event-handler nodig is, moet de expressie van de event-handelaar in een variabele worden opgeslagen en moet de registratie / uitschrijving via die variabele worden uitgevoerd:

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

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

De reden dat dit wordt gedaan in plaats van simpelweg de lambda-uitdrukking letterlijk opnieuw te typen om het abonnement op te zeggen ( -= ) is dat de C # compiler de twee uitdrukkingen niet noodzakelijk als gelijk beschouwt:

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

Merk op dat als extra instructies worden toegevoegd aan de lambda-expressie, de vereiste omringende accolades per ongeluk kunnen worden weggelaten, zonder compilatie-tijdfout te veroorzaken. Bijvoorbeeld:

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

Dit compileert, maar resulteert in het toevoegen van de lambda-expressie (sender, args) => Console.WriteLine("Email sent"); als een gebeurtenishandler en het uitvoeren van de instructie emailSendButton.Enabled = true; direct. Om dit te verhelpen, moet de inhoud van de lambda worden omgeven door accolades. Dit kan worden voorkomen door vanaf het begin accolades te gebruiken, voorzichtig te zijn bij het toevoegen van extra instructies aan een lambda-event-handler of de lambda vanaf het begin in ronde haakjes te plaatsen:

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