CSharp

5. LINQ

Dag 5: LINQ och lambda-uttryck

C# erbjuder LINQ (Language Integrated Query) som ett integrerat verktyg för att utföra datafrågor direkt i språket. Tillsammans med lambda-uttryck kan du använda LINQ för att skriva kort och kraftfull kod som bearbetar samlingar (som listor, arrayer, etc.) på ett deklarativt sätt.

1. Vad är LINQ?

LINQ (Language Integrated Query) är ett frågespråk som är inbyggt i C#. Det ger dig möjlighet att skriva frågor för att hämta, filtrera, sortera och manipulera data direkt i språket, utan att behöva gå igenom tredjepartslösningar. LINQ används ofta för att fråga och manipulera data från källor som arrayer, listor, XML-filer, databaser och till och med fjärrtjänster.

Varför LINQ?

Innan LINQ var det ofta nödvändigt att skriva långa och repetitiva loopar för att bearbeta data. LINQ introducerar ett mer deklarativt tillvägagångssätt, där du beskriver vad du vill göra med data, snarare än hur du gör det.

Exempel på loop-baserad kod utan LINQ:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
List<int> evenNumbers = new List<int>();

foreach (int number in numbers) {
    if (number % 2 == 0) {
        evenNumbers.Add(number);
    }
}

Samma kod med LINQ:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();

LINQ gör det möjligt att skriva mindre och mer lättläst kod. I detta exempel använder vi metoden Where för att filtrera ut jämna tal.

2. Lambda-uttryck

Lambda-uttryck är en kompakt och flexibel metod för att definiera anonyma funktioner (dvs. funktioner utan namn). Lambda-uttryck är mycket vanliga i LINQ och används ofta som parametrar till LINQ-metoder.

Syntax:

Ett lambda-uttryck består av en inparameterlista, ett =>-tecken (lambda-operatorn) och ett uttryck eller ett kodblock:

(parameterlista) => uttryck

Exempel:

int[] numbers = { 1, 2, 3, 4, 5 };
var squaredNumbers = numbers.Select(n => n * n).ToArray();

Här är n => n * n ett lambda-uttryck som tar en parameter n och returnerar kvadraten av den.

Funktionella komponenter i ett lambda-uttryck:

  • Parametrar: Värdena som tas in (t.ex. n i ovanstående exempel).
  • Uttryck: Vad som ska göras med parametrarna (t.ex. n * n).
  • Återgivning: Resultatet av lambda-uttrycket, som skickas tillbaka till den metod där lambda-uttrycket används.

3. Vanliga LINQ-metoder

LINQ använder sig av flera metoder som är mycket användbara när du arbetar med samlingar och andra datakällor. Här är några av de vanligaste:

Where

Where filtrerar data baserat på ett villkor.

Exempel:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();

I detta exempel filtreras alla jämna tal från numbers.

Select

Select används för att projicera data till en ny form. Detta är användbart för att omvandla varje element i en samling.

Exempel:

string[] names = { "John", "Jane", "Jake" };
var nameLengths = names.Select(name => name.Length).ToList();

Här skapar vi en lista med längderna på varje namn i names.

OrderBy och OrderByDescending

Dessa används för att sortera data i stigande respektive fallande ordning.

Exempel:

int[] numbers = { 5, 2, 9, 1, 4 };
var sortedNumbers = numbers.OrderBy(n => n).ToList();

Detta returnerar en lista där siffrorna är sorterade i stigande ordning.

GroupBy

GroupBy grupperar data baserat på en nyckel.

Exempel:

var students = new List<Student>
{
    new Student { Name = "John", Grade = "A" },
    new Student { Name = "Jane", Grade = "B" },
    new Student { Name = "Jake", Grade = "A" }
};
var groupedStudents = students.GroupBy(s => s.Grade);

Här grupperar vi studenter efter deras betyg.

First och FirstOrDefault

First returnerar det första elementet i en samling som matchar ett visst villkor, medan FirstOrDefault returnerar null om inget matchande element hittas.

Exempel:

int[] numbers = { 1, 2, 3, 4, 5 };
int firstEven = numbers.First(n => n % 2 == 0);  // Returnerar 2

Aggregate

Aggregate är användbart för att skapa en kumulativ beräkning på en samling.

Exempel:

int[] numbers = { 1, 2, 3, 4 };
int sum = numbers.Aggregate((total, next) => total + next);  // Resultat: 10

Här beräknar Aggregate summan av alla tal i listan.

4. Sortering, filtrering och projektioner med LINQ

LINQ gör det möjligt att kombinera olika operationer för att manipulera data på flera sätt, inklusive sortering, filtrering och projektioner (att omvandla data).

Exempel som kombinerar flera LINQ-metoder:

var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Filtrera jämna tal, kvadrera dem och sortera dem i fallande ordning
var result = numbers
    .Where(n => n % 2 == 0)
    .Select(n => n * n)
    .OrderByDescending(n => n)
    .ToList();

foreach (var num in result) {
    Console.WriteLine(num);  // Output: 100, 64, 36, 16, 4
}

Här filtreras alla jämna tal från listan, deras kvadrater beräknas, och sedan sorteras resultatet i fallande ordning.

5. Praktiska övningar för Dag 5

För att tillämpa dagens koncept kan du prova följande övningar:

  1. Grundläggande LINQ-fråga:

    • Skapa en lista med heltal och skriv en LINQ-fråga som filtrerar ut alla tal som är större än 10 och sorterar dem i stigande ordning.

  2. Filtrering och projektion:

    • Skapa en lista med objekt (t.ex. Person-objekt som har attribut som Name och Age) och använd LINQ för att filtrera ut alla personer över en viss ålder och projicera deras namn till en ny lista.

  3. Gruppering med LINQ:

    • Skapa en samling med produkter och gruppera dem efter kategori. Skriv sedan ut varje kategori tillsammans med en lista över produkterna i den kategorin.

  4. Användning av lambda-uttryck:

    • Använd Select-metoden tillsammans med ett lambda-uttryck för att skapa en ny lista som omvandlar en lista med tal till deras kvadratrötter.

Rekommenderad kodstruktur:

Använd LINQ och lambda-uttryck i små steg i din kod för att testa olika funktioner och uttryck. LINQ är kraftfullt men kan bli svårt att läsa om det används på ett alltför komplext sätt, så sträva efter att skriva tydlig och begriplig kod.

Efter Dag 5 kommer du att ha en stark förståelse för hur LINQ och lambda-uttryck fungerar i C#. Du kommer att kunna skriva effektiva och läsbara

frågor för att manipulera data, vilket är en ovärderlig färdighet när du arbetar med stora eller komplexa datastrukturer.

Dag 6