Ejecución diferida

1. Introducción

Imagínate: has escrito una consulta LINQ larga y bonita y piensas — «¡Voilà, ahora todo se va a procesar!» Pero luego te das cuenta de que no pasa nada hasta que cuentas los elementos o conviertes el resultado en un array. No es un bug, es una feature.

En .NET LINQ usa ejecución diferida: la consulta no se lanza hasta que realmente empiezas a sacar datos. Es como un camarero vago — no va a correr a la cocina hasta que escuche: «¡Trae la comida!», aunque el pedido ya esté hecho.

Este comportamiento, conocido como evaluación perezosa (Lazy Evaluation), hace que LINQ sea especialmente eficiente cuando trabajas con fuentes de datos grandes, potencialmente infinitas o que consumen muchos recursos.

Ejecución diferida significa que la consulta LINQ no se ejecuta justo después de definirla. Solo empieza a funcionar cuando realmente empiezas a recorrer o mirar los datos en la colección.

Ejemplo-ilustración

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Consulta LINQ
var query = numbers.Where(n =>{
    Console.WriteLine($"Comprobando {n}");
    return n % 2 == 0;
});
Console.WriteLine("Consulta definida, ¡pero los números no se han comprobado!");

// ¡Solo ahora empieza el recorrido!
foreach (var n in query)
{
    Console.WriteLine($"Encontrado par: {n}");
}

¿Qué va a pasar?
Cuando ejecutes este código, verás que antes del bucle foreach no se muestra nada en la consola — ni siquiera se ejecutan las condiciones en tu Where. En cuanto empiezas a recorrer los elementos (por ejemplo, con foreach), la consulta empieza a ejecutarse.

¡Eso es deferred execution — hasta que no lo pides, nadie hace nada!

2. ¿Para qué sirve la ejecución diferida?

La ejecución diferida hace que el código no solo sea elegante, sino también muy eficiente. ¿Para qué hacer un trabajo antes de tiempo si a lo mejor el resultado ni siquiera te va a hacer falta? Esto es especialmente importante cuando tienes colecciones grandes o flujos de datos que todavía están llegando — imagina una fuente que puede ser infinita. Cargar todo eso en memoria de golpe no tiene sentido.

Además, la ejecución diferida te permite combinar y encadenar consultas sin miedo a que se ejecuten de inmediato. Puedes construir cadenas complejas de operaciones LINQ y no preocuparte: solo se ejecutarán cuando realmente empieces a sacar datos — y ni un minuto antes.

Analogía

La ejecución diferida es como la lista de la compra en el móvil: puedes añadir y editar productos todo lo que quieras, pero solo vas a la tienda cuando realmente estás listo para comprar algo (y solo entonces usas esa lista).

3. ¿Cómo funciona por dentro?

Las consultas LINQ que devuelven IEnumerable<T> normalmente se implementan usando iteradores (yield return) o construcciones perezosas especiales. Cada vez que empiezas a recorrer la colección (por ejemplo, usando foreach o ToList()), la consulta se ejecuta de nuevo.

Observación importante

Si cambias la colección original entre la definición de la consulta y su ejecución, los datos nuevos o modificados también aparecerán en el resultado.

Ejemplo:

var numbers = new List<int> { 1, 2, 3 };
var query = numbers.Where(n => n > 1);
numbers.Add(4); // añadimos un número nuevo
foreach (var n in query)
{
    Console.WriteLine(n); // mostrará 2, 3, 4
}

Esquema: ¿cuándo se ejecuta una consulta LINQ?

flowchart TD
    A[Definición de la consulta LINQ] --> B{¿Ejecutar la consulta?}
    B -- No --> C[Esperando]
    B -- Sí (por ejemplo, foreach, ToList) --> D[Ejecución de la consulta]
    D --> E[Resultado o acción]

4. Ejemplos donde la "pereza" de LINQ importa

Filtrado perezoso

var bigNumbers = Enumerable.Range(1, 1_000_000_000)
    .Where(n => n % 123_456 == 0);

foreach (var n in bigNumbers.Take(5))
{
    Console.WriteLine(n);
}

¿Qué pasa aquí?
La consulta crea una colección potencialmente de mil millones, ¡pero en realidad solo filtra y devuelve 5 números! Todo lo demás ni se calcula ni ocupa memoria.

Consultas anidadas y transacciones

Supón que tienes una lista de pedidos y productos, y quieres obtener los primeros 5 pedidos que contienen un producto concreto.

var orders = GetBigOrderList(); // imagina que aquí hay miles de pedidos

var filtered = orders
    .Where(order => order.Products.Any(p => p.Name == "Café"))
    .Take(5);

foreach(var o in filtered)
{
    Console.WriteLine(o.Id);
}

¡LINQ no mira los demás pedidos cuando ya ha encontrado 5 que coinciden!

5. Sorpresas

Escenarios donde la ejecución diferida puede dar sorpresas:

Cambiar la fuente de datos después de definir la consulta

Como se mostró antes, si entre definir la consulta y ejecutarla cambias la colección original, la consulta verá los datos nuevos.

Recorrer una consulta varias veces

La consulta LINQ se ejecuta de nuevo cada vez que la recorres.

var query = numbers.Where(n => {
    Console.WriteLine($"Comprobando {n}");
    return n % 2 == 0;
});

foreach(var n in query) {} // primer recorrido
foreach(var n in query) {} // segundo recorrido — todo se recalcula otra vez

Si quieres un resultado repetible — materializa (haz .ToList() o .ToArray()).

6. ¿Cuándo las consultas LINQ NO son diferidas?

No todas las operaciones LINQ son diferidas. Algunos métodos hacen una ejecución inmediata ("ansiosa") (Immediate Execution). Por ejemplo:

• .ToList()
• .ToArray()
• .Count()
• .Average()
• .Sum()
• .First(), .Last(), .Single()

Todos estos hacen que LINQ ejecute la consulta de inmediato, porque no devuelven un IEnumerable, sino un resultado listo.

Ejemplo:

var query = numbers.Where(n => n > 2);
var result = query.ToList(); // ¡Aquí la consulta se ejecuta ya!

7. El concepto de "evaluación perezosa" (Lazy Evaluation)

La ejecución diferida (deferred execution) es un ejemplo concreto de evaluación perezosa (Lazy Evaluation) en .NET.

Evaluación perezosa es cuando el resultado no se calcula hasta que realmente hace falta. Además de LINQ, en C# hay otros mecanismos para cálculos perezosos.

Clase Lazy<T>

C# tiene un tipo especial Lazy<T> para crear valores "bajo demanda".

Ejemplo sencillo:

// Creamos un número perezoso que solo se calcula cuando lo pedimos
var lazyValue = new Lazy<int>(() =>
{
    Console.WriteLine("¡Calculando el valor!");
    return 42;
});

Console.WriteLine("Objeto Lazy creado, pero el valor no se ha calculado");
Console.WriteLine($"Valor: {lazyValue.Value}"); // aquí sí se calcula

¿Para qué sirve esto?
Por ejemplo, guardas un parámetro que rara vez necesitas, y calcularlo es lento o consume muchos recursos.

8. Tabla: métodos LINQ y modo de ejecución

Where

Select

Take

Skip

Join

ToList

ToArray

Count

First

9. Errores típicos y detalles de implementación

"Trabajo extra" por recorrer varias veces

Como la ejecución diferida provoca nuevos cálculos cada vez que recorres, a veces puedes hacer trabajo de más.

var expensiveQuery = bigList.Where(x => SomeHeavyCalculation(x));

var result1 = expensiveQuery.ToList(); // calculado — una vez
var result2 = expensiveQuery.ToList(); // calculado — dos veces (el mismo resultado, pero gastas tiempo otra vez)

Solución: materializa los datos una sola vez:
var cached = expensiveQuery.ToList();

"Atrapa el error si puedes"

Si una función en la consulta lanza una excepción, solo ocurrirá al recorrer la colección, no al definir la consulta.

Modificar la colección durante el recorrido

Cambiar la colección mientras la recorres puede lanzar una excepción InvalidOperationException.

2

Tarea

C# SELF, nivel 34, lección 0

Bloqueada

Ejecución diferida y múltiples consultas

Ejecución diferida y múltiples consultas

Abrir