O que é LINQ?

Question

O que é LINQ?

Accepted Answer

**LINQ** (Language Integrated Query) fornece uma forma unificada e expressiva de **consultar e transformar dados** — coleções, bancos de dados, XML — usando uma sintaxe consistente. Traz operações de estilo funcional (filtrar, mapear, agrupar, agregar) diretamente para C#, tornando a manipulação de dados concisa e legível.

## Sintaxe de método (a forma comum)

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

Os métodos LINQ (métodos de extensão em `IEnumerable<T>`) se encadeiam para construir pipelines de dados expressivos — filtragem (`Where`), transformação (`Select`), ordenação, agrupamento e agregação — muito mais limpo do que loops manuais. As lambdas (`p => ...`) são delegates.

## Sintaxe de consulta (alternativa semelhante a 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 é adiado (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
```

A maioria dos operadores LINQ é **adiada** — eles constroem uma consulta que é executada apenas quando você a enumera (ou chama `ToList()`/`Count()`), permitindo composição eficiente.

## LINQ sobre bancos de dados (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
```

Com Entity Framework, as mesmas consultas LINQ funcionam em um banco de dados (traduzidas para SQL) — uma unificação poderosa.

## Por que isso importa

LINQ é um dos recursos mais poderosos e distintivos do C# — transformou a forma como C# lida com dados ao fornecer uma forma unificada, expressiva e de estilo funcional de consultar e transformar coleções, bancos de dados e outras fontes, portanto, compreendê-lo é essencial para o desenvolvimento produtivo em C#.

O valor principal é substituir loops imperativos verbosos por pipelines de consulta concisos, legíveis e compostos (`Where`/`Select`/`OrderBy`/`GroupBy`/agregações) para filtrar, transformar, agrupar e agregar dados — operações que aparecem constantemente no código real.

A **unificação** do LINQ é particularmente significativa: a *mesma* sintaxe consulta coleções em memória e **bancos de dados** (via Entity Framework, traduzido para SQL) e outras fontes, portanto, aprender LINQ compensa em muitos cenários.

Compreender a sintaxe de método (a forma comum, usando lambdas/delegates), sintaxe de consulta (a alternativa semelhante a SQL), os operadores comuns e especialmente **execução adiada** (consultas LINQ são lazy, executadas apenas na enumeração — importante tanto para eficiência quanto para evitar surpresas) é conhecimento importante para escrever código limpo e eficiente de manipulação de dados.

Como consulta e transformação de dados são onipresentes, e como LINQ é a forma idiomática e poderosa que C# as manipula (em coleções e bancos de dados), dominar LINQ é conhecimento fundamental, frequentemente aplicado, que é uma marca registrada do desenvolvimento C# produtivo e uma característica definidora da linguagem — tornando-a um tópico comum e importante em entrevistas.