Sintaxe LINQ: Method Syntax vs Query Syntax

1. Introdução

No mundo do LINQ, existem duas "escolas" principais de escrever consultas, dois estilos que, à primeira vista, parecem bem diferentes. São eles: Query Syntax (sintaxe de consulta) e Method Syntax (sintaxe de métodos). E se você já pensou que programar é só lógica, hoje a gente vai colocar um pouco de arte nisso, porque escolher a sintaxe é tipo escolher entre pincel e lápis: os dois desenham, mas um pode ser melhor pra cor, outro pro contorno.

Por que dois estilos? Boa pergunta! Imagina que você quer pedir um café. Você pode falar: "Me vê um espresso com leite e uma colher de açúcar, por favor?". Ou pode escrever num papel: "Espresso. Leite. 1 açúcar". Os dois jeitos funcionam, mas um é mais conversado, o outro é mais direto.

Com LINQ é igual. Um estilo foi criado pra parecer com SQL, o outro pra ser mais "C#-like" e flexível. No fim das contas, o compilador C# transforma os dois estilos na mesma coisa: chamadas de métodos. Então, a escolha geralmente é questão de legibilidade e gosto pessoal.

Bora ver os dois.

2. Method Syntax

Esse é o jeito onde você vai encadeando métodos de extensão LINQ usando ponto. Esse estilo é bem popular entre devs .NET porque é fácil adicionar operações novas, o resultado sempre é um IEnumerable<T>, e dá pra escrever direto no código de boa.

Exemplo: Filtrar e ordenar produtos

var filteredProducts = products
    .Where(p => p.Price < 1000)          // Filtrando pelo preço
    .OrderBy(p => p.Name)                // Ordenando pelo nome
    .ToList();                           // Convertendo pra List<Product>

Where, OrderBy e ToList são métodos de extensão LINQ, cada um retorna um novo conjunto de dados que você pode continuar processando.

Esquema

graph LR
A[products] --> B[Where]
B --> C[OrderBy]
C --> D[ToList]

Por que Method Syntax é massa

• Super flexível: dá pra montar cadeias complexas de várias operações fácil.
• Todos os métodos são só métodos C#, a IDE ajuda com autocomplete.
• Dá pra fazer quase tudo do LINQ (e até mais).

Outro exemplo: pegar nomes de todos usuários com mais de 18 anos

Imagina que temos uma classe User:

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Agora vamos pegar os nomes dos usuários adultos:

List<User> users = ... // declarado em algum lugar

var adultNames = users
    .Where(u => u.Age >= 18)
    .Select(u => u.Name)
    .ToList();

3. Query Syntax (sintaxe parecida com SQL)

Essa sintaxe foi criada pra quem já manja de SQL se sentir em casa no C#. Ela parece uma consulta de banco de dados e começa com a palavra-chave from.

Exemplo: mesmo filtro e ordenação

var filteredProducts = 
    from p in products
    where p.Price < 1000
    orderby p.Name
    select p;

Aqui, tudo soa como uma consulta clássica: "da coleção products pega p, onde p.Price < 1000, ordena por p.Name, seleciona p".

Esquema

flowchart TD
    A[products] -->|from p in products| B[where p.Price < 1000]
    B --> C[orderby p.Name]
    C --> D[select p]

Por que Query Syntax é massa

• Parece SQL, então é mais fácil pra quem já mexeu com banco de dados.
• Mais legível pra consultas longas com várias condições, agrupamentos, joins (join).

Outro exemplo: pegar nomes dos usuários adultos

var adultNames = 
    from u in users
    where u.Age >= 18
    select u.Name;

Fica ligado: Aqui, logo depois do select dá pra pegar só um campo — tipo, só o nome.

4. Comparando: Method Syntax vs Query Syntax

users.Where(...).Select(...)

from u in users where ... select ...

Sum

Count

IEnumerable<T>

IEnumerable<T>

.ToList()

Curiosidade da vida real

A maioria dos exemplos na documentação oficial da Microsoft sobre LINQ aparece nos dois estilos. Mas no código do dia a dia, o Method Syntax é mais comum — ele é mais prático pra usar com métodos de extensão (Where, Select, OrderBy e por aí vai).

Misturar ou não misturar? Qual estilo escolher

Pode misturar os dois estilos no mesmo projeto (até na mesma consulta — mas aí fica estranho). O importante é não virar bagunça. Normalmente, escolhe-se um estilo pra todo o módulo ou projeto, pra facilitar a leitura.

Method Syntax é ótimo pra transformações em sequência e pra usar todos os métodos LINQ que só existem como métodos (Sum, Count, Any e outros).

Query Syntax é muito bom pra tarefas com join, group by ou condições complexas em vários níveis — aí ele ganha em legibilidade.

5. Convertendo entre estilos: é tudo igual, só muda o jeito

Por dentro, o LINQ no C# transforma qualquer consulta tipo SQL (Query Syntax) numa cadeia de chamadas de métodos (Method Syntax). Ou seja, não importa como você escreve, o C# vai converter pra métodos de extensão na hora de compilar.

Exemplo 1 — filtragem:

Query Syntax:

var adults = from u in users
             where u.Age >= 18
             select u;

Method Syntax (igualzinho):

var adults = users.Where(u => u.Age >= 18);

Exemplo 2 — seleção de campos (Select):

Query Syntax:

var names = from u in users
            select u.Name;

Method Syntax:

var names = users.Select(u => u.Name);

7. Agrupamentos e joins (join, group by)

Criando novos objetos

Vamos adicionar no nosso app de estudo a opção de mostrar a lista de usuários agrupados por idade. Aqui a diferença de sintaxe fica bem clara.

Query Syntax (agrupamento):

var usersByAge = 
    from u in users
    group u by u.Age into ageGroup
    select new { Age = ageGroup.Key, Users = ageGroup.ToList() };

A gente agrupa os usuários pela idade (group u by u.Age). Depois do into aparece a variável ageGroup — que já é o grupo em si.

Method Syntax (igualzinho):

var usersByAge = users
    .GroupBy(u => u.Age)
    .Select(ageGroup => new { Age = ageGroup.Key, Users = ageGroup.ToList() });

Mais difícil: join (join)

Imagina que temos uma lista de pedidos (orders) e uma lista de usuários (users). Queremos pegar os nomes dos usuários e o valor dos pedidos deles.

Query Syntax:

var userOrders =
    from user in users
    join order in orders on user.Id equals order.UserId
    select new { user.Name, order.Amount };

Method Syntax:

var userOrders = users.Join(
    orders,
    user => user.Id,
    order => order.UserId,
    (user, order) => new { user.Name, order.Amount }
);

8. Erros comuns, pegadinhas e dicas

Um erro clássico: se você não colocar .ToList(), o resultado não é uma lista, mas sim uma "consulta preguiçosa" (lazy query), que só vai rodar quando você percorrer ela pela primeira vez. Isso é útil, mas pode dar uns bugs se a coleção original mudar depois que você escreveu a consulta. Vamos falar mais sobre "execução preguiçosa" depois (quando a gente ver os métodos LINQ).

Muita gente que tá começando acha que dá pra usar todos os métodos LINQ no Query Syntax. Mas não dá. Por exemplo, não rola escrever select sum(u.Age), tem que ir pro Method Syntax (users.Sum(u => u.Age)).