Wat is LINQ?

Question

Wat is LINQ?

Accepted Answer

**LINQ** (Language Integrated Query) biedt een uniforme, expressieve manier om **gegevens op te vragen en te transformeren** — collecties, databases, XML — met behulp van een consistente syntaxis. Het brengt functionaal-style operaties (filteren, mappen, groeperen, aggregeren) rechtstreeks in C#, waardoor gegevensmanipulatie beknopt en leesbaar wordt.

## Method syntax (de meest voorkomende vorm)

```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-methoden (extension methods op `IEnumerable<T>`) zijn aaneengekoppeld om expressieve datapipelijen te bouwen — filteren (`Where`), transformeren (`Select`), ordenen, groeperen en aggregeren — veel schoner dan handmatige loops. De lambdas (`p => ...`) zijn delegates.

## Query syntax (SQL-achtig alternatief)

```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 is uitgesteld (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 meeste LINQ-operatoren zijn **uitgesteld** — ze bouwen een query die alleen wordt uitgevoerd wanneer je er doorheen loopt (of `ToList()`/`Count()` aanroept), waardoor efficiënte samenstelling mogelijk is.

## LINQ over databases (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
```

Met Entity Framework werken dezelfde LINQ-query's tegen een database (vertaald naar SQL) — een krachtige unificatie.

## Waarom het belangrijk is

LINQ is een van C#'s krachtigste en meest kenmerkende features — het heeft getransformeerd hoe C# met gegevens omgaat door een uniforme, expressieve, functionaal-style manier te bieden om collecties, databases en andere bronnen op te vragen en te transformeren, dus het begrijpen ervan is essentieel voor productieve C#-ontwikkeling.

De kernwaarde is het vervangen van uitgebreide, imperatieve loops door beknopte, leesbare, samenstelbare query-pipelines (`Where`/`Select`/`OrderBy`/`GroupBy`/aggregaties) voor filteren, transformeren, groeperen en aggregeren van gegevens — operaties die voortdurend in echte code voorkomen.

De **unificatie** van LINQ is bijzonder significant: dezelfde syntaxis vult collecties in het geheugen en **databases** (via Entity Framework, vertaald naar SQL) en andere bronnen op, dus het leren van LINQ loont zich in veel scenario's.

Het begrijpen van method syntax (de meest voorkomende vorm, met lambdas/delegates), query syntax (het SQL-achtige alternatief), de veel voorkomende operatoren, en vooral **uitgestelde uitvoering** (LINQ-query's zijn lui, ze voeren alleen uit bij opsomming — belangrijk voor zowel efficiëntie als het voorkomen van verassingen) is belangrijk kennis voor het schrijven van schone, efficiënte gegevensmanipulatiecode.

Omdat het opvragen en transformeren van gegevens alomtegenwoordig is, en omdat LINQ de idiomatische, krachtige manier is waarop C# ermee omgaat (over collecties en databases heen), is het beheersen van LINQ kernkennis die veel wordt toegepast, een kenmerk van productieve C#-ontwikkeling en een onderscheidend kenmerk van de taal — waardoor het een veel voorkomend, belangrijk interviewonderwerp is.