Lambda-uttryck

Välj ett lambda-uttryck när du vill skicka en kort åtgärd till en annan metod och åtgärden är tydligast bredvid anropet som använder den. En infogad regel visar läsarna hur du väljer eller transformerar objekt; en namngiven metod låter dem följa åtgärdens syfte innan de inspekterar dess detaljer.

Tip

Den här artikeln lär dig praktiska val för utvecklare som känner till C#-metoder och -samlingar. Fullständig lambda-syntax och -regler finns i lambda-uttrycksreferensen.

Ett lambda-uttryck är en namnlös funktion som du skriver där en annan koddel behöver beteende.

Följande lambda accepterar en session och returnerar om sessionen har lediga platser:

session => session.Registered < session.Capacity

Operatorn => separerar parametrarna till vänster från funktionskroppen till höger. Läs det som "går till".

Skicka med beteende till en metod

Många .NET API:er accepterar en delegering, vilket är en typ som representerar beteende med en viss parameterlista och returtyp. Ett lambda-uttryck tillhandahåller detta beteende. En introduktion till delegattyper som Func och Action finns i Lambda-uttryck, ombud och händelser.

Följande exempel fungerar med workshopsessioner. En WorkshopSession innehåller en rubrik, varaktighet, kapacitet och registreringsantal.

int maximumMinutes = 60;

var shortSessions = sessions
    .Where(session => session.DurationMinutes <= maximumMinutes)
    .OrderBy(session => session.Title);

foreach (WorkshopSession session in shortSessions)
{
    Console.WriteLine(session.Title);
}

Den första lambda berättar Where vilka sessioner som ska behållas. Det andra anger OrderBy vilket värde som ska sorteras efter. Metoderna får beteende utan att känna till detaljerna för någon av reglerna.

Välj ett formulär för parametrar

Välj det kortaste parameterformuläret som fortfarande är tydlig:

session => session.DurationMinutes <= 60

För en parameter utelämnar du parenteser när kompilatorn kan härleda typen. Använd tomma parenteser när det inte finns några parametrar:

() => DateTime.Now

Använd parenteser för två eller flera parametrar:

(left, right) => left + right

Vanligtvis tillhandahåller metoden som tar emot lambda tillräckligt med information för att kompilatorn ska kunna härleda parametertyper. Skriv explicita typer när typinferensen behöver hjälp eller när typerna förbättrar tydligheten:

(WorkshopSession session) => session.Title

Referensen för lambda-uttryck omfattar parametermodifierare, attribut, standardvärden och andra specialiserade formulär.

Välj ett uttryck eller en satskropp

Använd ett uttryck lambda när ett uttryck beräknar resultatet:

session => session.Registered < session.Capacity

Använd en satslambda när operationen behöver mer än en instruktion. Omslut kroppen i klammerparenteser och inkludera return när lambda returnerar ett värde:

var descriptions = sessions.Select(session =>
{
    int seatsLeft = session.Capacity - session.Registered;
    string availability = seatsLeft > 0 ? $"{seatsLeft} seats left" : "full";
    return $"{session.Title}: {availability}";
});

Console.WriteLine(string.Join(Environment.NewLine, descriptions));

Håll satslambdauttryck korta. När metoden behöver flera steg eller om samma logik visas mer än en gång ger du beteendet ett beskrivande namn med en lokal funktion eller vanlig metod.

Samla in värden från den omgivande kontexten

En lambda kan använda en variabel som deklarerats i den omgivande metoden. Den här användningen kallas fångst. I det första exemplet fångar urvalslambdan maximumMinutes:

int maximumMinutes = 60;
var shortSessions = sessions.Where(
    session => session.DurationMinutes <= maximumMinutes);

Infångning hjälper en kort regel att använda lokal kontext. Lambdan fångar själva variabeln, inte en kopia av dess värde. Om variabeln ändras innan lambda körs ser lambda det aktuella värdet.

Gör den kontext som behövs enkel att identifiera. Om en lambda inte behöver omgivande tillstånd lägger du till static för att förhindra oavsiktlig fångst och göra det oberoendet synligt för läsarna:

var openSessions = sessions.Where(
    static session => session.Registered < session.Capacity);

En statisk lambda kan använda sina parametrar, värden som den deklarerar, konstanter och statiska medlemmar. Den kan inte använda lokala variabler eller instanstillstånd från den omgivande koden.

Välj ett lambdauttryck, en metodgrupp eller en lokal funktion

Flera C#-formulär kan ge beteende till en delegatparameter:

  • Använd ett lambda-uttryck för kort beteende som tydligt kan läsas bredvid anropet.
  • Använd en metodgrupp när en befintlig metod har den signatur som krävs och namnet förklarar beteendet.
  • Använd en lokal funktion när den innehållande medlemmen behöver återanvändbar namngiven logik, rekursion eller en funktionskropp som är för stor för en infogad lambda.
  • Använd en vanlig memberfunktion när flera medlemmar behöver beteendet.

En method group är ett metodnamn utan argumentlista. Kompilatorn konverterar matchningsmetoden till den obligatoriska delegattypen:

var openSessions = sessions.Where(HasOpenSeats);

foreach (WorkshopSession session in openSessions)
{
    Console.WriteLine($"Open: {session.Title}");
}

static bool HasOpenSeats(WorkshopSession session) =>
    session.Registered < session.Capacity;

Where(HasOpenSeats) kommunicerar samma regel som Where(session => HasOpenSeats(session)) med mindre kod. Metodnamnet talar om för läsarna vad regeln testar; en infogad jämförelse visar hur den testar regeln. Behåll lambda-omslutningen när den lägger till ett argument, kombinerar åtgärder eller gör anropet tydligare.

För en detaljerad lokal jämförelse, se Lokala funktioner.

Se även

  • Uppdaterades senast