Hvad er LINQ?

Question

Hvad er LINQ?

Accepted Answer

**LINQ** (Language Integrated Query) leverer en ensartet, udtryksfuld måde at **forespørge og transformere data** — samlinger, databaser, XML — ved hjælp af ensartet syntaks. Det bringer funktionsstil-operationer (filter, map, group, aggregate) direkte ind i C#, hvilket gør datamanipulation kortfattet og læsbar.

## Metodesyntaks (den almindelige form)

```csharp
var adults = people
    .Where(p => p.Age >= 18)             // filter
    .OrderBy(p => p.Name)                 // sort
    .Select(p => p.Name.ToUpper())        // transform (map)
    .ToList();                            // materialize

// aggregations and more
int total = numbers.Sum();
var count = people.Count(p => p.IsActive);
var first = people.FirstOrDefault(p => p.Id == 5);   // null if none
bool any = people.Any(p => p.Age > 65);
var groups = people.GroupBy(p => p.City);            // group by a key
var max = people.Max(p => p.Age);
```

LINQ-metoder (udvidelsesmetoder på `IEnumerable<T>`) kædes sammen for at bygge udtryksfulde datapipelines — filtrering (`Where`), transformering (`Select`), sortering, gruppering og aggregering — langt mere rent end manuelle løkker. Lambdaerne (`p => ...`) er delegater.

## Forespørgselssyntaks (SQL-lignende alternativ)

```csharp
var adults =
    from p in people
    where p.Age >= 18
    orderby p.Name
    select p.Name;
// equivalent to the method syntax — a more SQL-like style for complex queries
```

## LINQ er udskudt (lazy)

```csharp
var query = people.Where(p => p.IsActive);   // NOT executed yet (deferred)
foreach (var p in query) { }                  // executes NOW (on enumeration)
var list = query.ToList();                     // or force execution with ToList/ToArray/Count
```

De fleste LINQ-operatorer er **udskudt** — de bygger en forespørgsel, der kun udføres, når du enumererer den (eller kalder `ToList()`/`Count()`), hvilket tillader effektiv sammensætning.

## LINQ over databaser (Entity Framework)

```csharp
// the SAME LINQ syntax queries a DATABASE — translated to SQL by Entity Framework
var users = await db.Users.Where(u => u.Active).OrderBy(u => u.Name).ToListAsync();
// → translated to: SELECT * FROM Users WHERE Active = 1 ORDER BY Name
```

Med Entity Framework fungerer de samme LINQ-forespørgsler mod en database (oversat til SQL) — en kraftfuld forening.

## Hvorfor det betyder noget

LINQ er en af C#'s mest kraftfulde og karakteristiske funktioner — det transformerede, hvordan C# håndterer data ved at tilbyde en ensartet, udtryksfuld, funktionsstil-måde at forespørge og transformere samlinger, databaser og andre kilder på, så det at forstå det er væsentligt for produktiv C#-udvikling.

Kernværdien er at erstatte verbose, imperative løkker med kortfattede, læsbare, sammensættelige forespørgselspipelines (`Where`/`Select`/`OrderBy`/`GroupBy`/aggregeringer) til filtrering, transformering, gruppering og aggregering af data — operationer, der optræder konstant i rigtig kode.

LINQ's **forening** er særlig vigtig: den *samme* syntaks forespørger samlinger i hukommelsen og **databaser** (via Entity Framework, oversat til SQL) og andre kilder, så læring af LINQ betaler sig på tværs af mange scenarier.

Forståelse af metodesyntaks (den almindelige form ved hjælp af lambdaer/delegater), forespørgselssyntaks (det SQL-lignende alternativ), de almindelige operatorer og især **udskudt udførelse** (LINQ-forespørgsler er lazy, udføres kun ved enumerering — vigtig for både effektivitet og undgåelse af overraskelser) er vigtig viden til at skrive ren, effektiv datamapupuleringskode.

Da dataforespørgsel og -transformation er allestedsnærværende, og da LINQ er den idiomatiske, kraftfulde måde, C# håndterer dem på (på tværs af samlinger og databaser), er det at beherske LINQ kernekompetence, hyppigt anvendt viden, der er kendetegnet på produktiv C#-udvikling og en definerende feature for sproget — hvilket gør det til et almindeligt, vigtigt interviewemne.