Lambda-uttryck debuterade med Dotnet 3.5 samtidigt som Language integrated query (LINQ) blev tillgängligt. Lambda-uttryck liknar anonyma metoder, men har större flexibilitet. När du använder ett lambda-uttryck behöver du inte specificera typ av indata. Därför är lambda-uttryck ett enklare och renare sätt att representera anonyma metoder.

I den här artikeln ska vi se hur man kan använda lambda-uttryck i C#. För att jobba med de exempel på kod som ingår i denna artikel bör du ha Visual Studio 2019 på din dator.

Så skapar du ett konsol applikation projekt i Visual Studio

Till att börja med skapar vi ett Dotnet Core-konsolapplikationsprojekt i Visual Studio. Om du har Visual Studio 2019 installerat följer du stegen här nedanför:

  1. Starta Visual Studios utvecklingsmiljö (IDE).
  2. Klicka på ”Create new project”.
  3. I fönstret ”Create new project” väljer du “Console App (.NET Core)” från listan med mallar.
  4. Klicka på ”Next”.
  5. I fönstret “Configure your new project” som visas då anger du namn och plats för ditt nya projekt.
  6. Klicka på ”Create”.

Om du följer dessa steg bör du ha ett nytt Dotnet Core-konsolapplikationsprojekt i Visual Studio. Vi använder det projektet för att arbeta med lambda-uttryck i C# i fortsättningen av denna artikel.

Lambda-uttryckets anatomi

I grund och botten är ett lambda-uttryck en metod som saknar deklaration. Med andra ord är ett lambda-uttryck en metod som inte har accessspecifierare eller namn. Ett lambda-uttryck kan delas i två bitar: vänstra delen och högra delen. Vänstra delen används för indata, högra delen använder man för att skriva uttryck.

Detta är syntaxen för lambda-uttryck som ska användas i C#.

(Input parameters) => Uttryck eller programsatsblock
Det finns två typer av lambda-uttryck: uttryckslambda och programsatslambda. En uttryckslambda består av indata till vänster och ett uttryck till högre, som här nedanför:

indata => expression;
En programsatslambda består av indata till vänster och en uppsättning programsatser till höger, som här nedanför:

indata => { programsatser };

Exempel på lambda-uttryck i C#

Det är lätt att skriva ett lambda-uttryck. Allt du behöver göra är att ta bort delegatnyckelord och parametertyp från en anonym metod. Betrakta följande anonyma metod som har både delegatnyckelord och parametertyp:

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

Denna programsats kan göras om till ett lambda-uttryck på det sätt som visas här nedanför:

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

I den programsatsen är a parametern och => är lambda-operatorn. Följande programsats är uttrycket:

a.IsActive && a.NoOfBooksAuthored > 10;

Här är ett annat exempel på ett lambda-uttryck som visar de udda talen från 1 till 9 i konsolfönstret:

List<int> integers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
foreach(int num in integers.Where(n => n % 2 == 1).ToList())
{
Console.WriteLine(num);
}

Lambda-uttryck med och utan parametrar

Lambda-uttryck kan sakna parametrar eller ha en eller flera parametrar. Följande kodsnutt visar ett lambda-uttryck helt utan parametrar:

() => Console.WriteLine("Detta är ett lambda-uttryck helt utan parametrar");

Men lambda-uttryck kan också ha en eller flera parametrar. Följande kodsnutt är ett exempel på en parameter:

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

Du kan också specificera typ av parameter i ett lambda-uttryck, vilket visas i kodsnutten som följer här:

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

Du kan till och med specificera flera programsatser i ett lambda-uttryck genom att använda klammerparenteser. Se följande kodsnutt:

(a, 10) =>
{
Console.WriteLine("This is an example of a lambda expression
with multiple statements");
return a.NoOfBooksAuthored >= 10;
}

Programsatslambda i C#

En programsatslambda använder identiskt samma syntax som en uttryckslambda. Skillnaden är att i stället för att det är ett uttryck till höger om operatorn har en programsatslambda ett kodblock med en eller flera programsatser.

Följande kodsnutt illustrerar fördelarna med att använda en programsatslambda för att visa de udda talen från 1 till 9 i konsolfönstret:

int[] integers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
foreach (int i in integers.Where(x =>
{
if (x % 2 == 0)
return true;
return false;
}
))
Console.WriteLine(i);

Lambda-uttryck är ett utmärkt inslag i Dotnet och Dotnet Core. De är ett enklare sätt att definiera anonyma metoder. Lambda-uttryck kan ha noll parametrar eller en, eller flera. Du kan till och med knyta lambda-uttryck till delegaterna Func, Action och Predicate. I en kommande artikel ska vi gå igenom dessa och andra funktioner i lambda-uttryck. Vi ska också titta på hur man kan arbeta med lambda-uttryck och LINQ samt med asynkrona lambda.