Qu'est-ce que LINQ?

Question

Qu'est-ce que LINQ?

Accepted Answer

**LINQ** (Language Integrated Query) fournit un moyen **unifié et expressif de requêter et transformer les données** — collections, bases de données, XML — en utilisant une syntaxe cohérente. Il apporte les opérations de style fonctionnel (filtrer, mapper, regrouper, agréger) directement en C#, rendant la manipulation de données concise et lisible.

## Syntaxe par méthode (la forme courante)

```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);
```

Les méthodes LINQ (méthodes d'extension sur `IEnumerable<T>`) s'enchaînent pour construire des pipelines de données expressifs — filtrage (`Where`), transformation (`Select`), tri, regroupement et agrégation — beaucoup plus propre que les boucles manuelles. Les lambdas (`p => ...`) sont des délégués.

## Syntaxe de requête (alternative de type SQL)

```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 est différé (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
```

La plupart des opérateurs LINQ sont **différés** — ils construisent une requête qui s'exécute uniquement quand vous l'énumérez (ou appelez `ToList()`/`Count()`), permettant une composition efficace.

## LINQ sur les bases de données (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
```

Avec Entity Framework, les mêmes requêtes LINQ fonctionnent contre une base de données (traduites en SQL) — une unification puissante.

## Pourquoi c'est important

LINQ est l'une des fonctionnalités les plus puissantes et distinctives de C# — elle a transformé la façon dont C# gère les données en fournissant un moyen unifié, expressif et de style fonctionnel de requêter et transformer les collections, bases de données et autres sources, donc la comprendre est essentielle pour un développement C# productif.

La valeur fondamentale est de remplacer les boucles verbeuses et impératives par des pipelines de requête concis, lisibles et composables (`Where`/`Select`/`OrderBy`/`GroupBy`/agrégations) pour filtrer, transformer, regrouper et agréger les données — des opérations qui apparaissent constamment dans du code réel.

L'**unification** de LINQ est particulièrement significative : la *même* syntaxe requête les collections en mémoire et les **bases de données** (via Entity Framework, traduites en SQL) et autres sources, donc apprendre LINQ paie dans de nombreux scénarios.

Comprendre la syntaxe par méthode (la forme courante, utilisant des lambdas/délégués), la syntaxe de requête (l'alternative de type SQL), les opérateurs courants, et surtout l'**exécution différée** (les requêtes LINQ sont lazy, s'exécutant uniquement à l'énumération — important pour l'efficacité et éviter les surprises) est une connaissance importante pour écrire du code propre et efficace de manipulation de données.

Puisque la requête et la transformation de données sont omniprésentes, et puisque LINQ est le moyen idiomatique et puissant par lequel C# les gère (sur les collections et les bases de données), maîtriser LINQ est une connaissance fondamentale, fréquemment appliquée, qui est une caractéristique du développement C# productif et une fonctionnalité distinctive du langage — en faisant un sujet fréquent et important d'entretien.