Sintaxis LINQ: Method Syntax vs Query Syntax

1. Introducción

En el mundo de LINQ hay dos "escuelas" principales para escribir consultas, dos estilos que a primera vista pueden parecer totalmente distintos. Son Query Syntax (sintaxis de consulta) y Method Syntax (sintaxis de métodos). Y si alguna vez pensaste que programar es pura lógica, hoy le vamos a poner un poco de arte, porque elegir la sintaxis es como elegir entre pincel y lápiz: ambos dibujan, pero uno puede ser mejor para el color y otro para el contorno.

¿Por qué necesitamos dos sintaxis? ¡Buena pregunta! Imagina que quieres pedir un café. Puedes decir: "¿Me pones un espresso con leche y una cucharadita de azúcar, por favor?". O puedes escribir en un papel: "Espresso. Leche. 1 azúcar". Las dos formas se entienden, pero una es más conversacional y la otra más corta.

Así pasa con LINQ. Una sintaxis fue creada para parecerse lo máximo posible al lenguaje de bases de datos SQL, y la otra para ser más "C#-era" y flexible. Al final, el compilador de C# convierte ambas en lo mismo: llamadas a métodos. Así que la elección suele ser cuestión de legibilidad y gustos personales.

Vamos a ver ambas.

2. Method Syntax

Esta es la opción donde vas encadenando métodos de extensión LINQ usando el punto. Este enfoque es súper popular entre los desarrolladores .NET porque es fácil añadir nuevas operaciones, el resultado siempre es IEnumerable<T>, y es cómodo de escribir directamente en el código.

Ejemplo: Filtrar y ordenar productos

var filteredProducts = products
    .Where(p => p.Price < 1000)          // Filtramos por precio
    .OrderBy(p => p.Name)                // Ordenamos por nombre
    .ToList();                           // Convertimos a List<Product>

Where, OrderBy y ToList son métodos de extensión LINQ, cada uno devuelve un nuevo conjunto de datos que puedes seguir procesando.

Esquema

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

¿Por qué mola Method Syntax?

• Muy flexible: puedes montar cadenas complejas de muchas operaciones fácilmente.
• Todos los métodos son métodos C#, el IDE te ayuda con el autocompletado.
• Permite hacer casi todo lo que hay en LINQ (¡y más!).

Otro ejemplo: seleccionar los nombres de todos los usuarios mayores de 18 años

Supón que tenemos una clase User:

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

Ahora seleccionamos los nombres de los usuarios adultos:

List<User> users = ... // declarado en algún sitio

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

3. Query Syntax (sintaxis tipo SQL)

Esta sintaxis fue inventada para que los desarrolladores de C# se sintieran como en casa si ya habían trabajado con SQL. Se parece a las consultas de base de datos y empieza con la palabra clave from.

Ejemplo: el mismo filtro y orden

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

Aquí todo se lee como una consulta clásica: "de la colección products coge p, donde p.Price < 1000, ordena por p.Name, selecciona 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 qué mola Query Syntax?

• Parece SQL, así que es más fácil de entender si ya has trabajado con bases de datos.
• Más legible para consultas largas con varias condiciones, agrupaciones, joins (join).

Otro ejemplo: seleccionar los nombres de los usuarios adultos

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

Ojo: Aquí justo después de select puedes elegir no todo el objeto, sino un campo concreto — por ejemplo, solo el nombre.

4. Comparativa: Method Syntax vs Query Syntax

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

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

Sum

Count

IEnumerable<T>

IEnumerable<T>

.ToList()

Dato curioso de la vida real

La mayoría de los ejemplos en la documentación oficial de Microsoft sobre LINQ se dan en ambos estilos. Pero en el código de producción cada vez se ve más Method Syntax — es más cómodo cuando usas métodos de extensión (Where, Select, OrderBy, etc).

¿Mezclar o no mezclar? Qué estilo elegir

Puedes mezclar ambos estilos en un mismo proyecto (¡incluso en una misma consulta! — aunque queda raro). Lo importante es no hacer una ensalada de código. Normalmente se elige un estilo para todo el módulo o proyecto, para que el código sea más fácil de leer.

Method Syntax va genial para transformaciones secuenciales y para usar todos los métodos LINQ que solo existen como métodos (Sum, Count, Any y algunos más).

Query Syntax es súper útil para tareas con join, group by o condiciones complejas multinivel — ahí gana en legibilidad.

5. Convertir entre estilos: lo mismo, pero diferente

LINQ dentro de C# convierte cualquier consulta tipo SQL (Query Syntax) en una cadena de llamadas a métodos (Method Syntax). O sea, escribas lo que escribas, C# lo transforma a métodos de extensión al compilar.

Ejemplo 1 — filtrado:

Query Syntax:

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

Method Syntax (equivalente):

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

Ejemplo 2 — selección de campos (Select):

Query Syntax:

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

Method Syntax:

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

7. Agrupaciones y joins (join, group by)

Crear nuevos objetos

Vamos a añadir a nuestra app de prácticas la posibilidad de mostrar la lista de usuarios agrupados por edad. Aquí la diferencia de sintaxis se nota mucho más.

Query Syntax (agrupación):

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

Agrupamos usuarios por edad (group u by u.Age). Después de into aparece la variable ageGroup — que es el propio grupo.

Method Syntax (equivalente):

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

Más difícil: join (join)

Supón que tienes una lista de pedidos (orders) y una lista de usuarios (users). Queremos obtener los nombres de los usuarios y la suma de sus pedidos.

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. Errores típicos, trampas y trucos

Uno de los errores más comunes: si no añades .ToList(), el resultado no es una lista, sino una "consulta diferida" (lazy query), que solo se ejecuta la primera vez que la recorres. Es útil, pero puede dar resultados raros si la colección original cambia después de escribir la consulta. Hablaremos más sobre "ejecución diferida" más adelante (después de ver los métodos LINQ).

Muchos principiantes se lían pensando que pueden usar todos los métodos LINQ en Query Syntax. Por ejemplo, no puedes escribir simplemente select sum(u.Age), tienes que pasar a Method Syntax (users.Sum(u => u.Age)).