0Pricing
C# Academy · Lección

Pipelines de IEnumerable<T> y ejecución diferida

Construya pipelines de LINQ sobre IEnumerable y comprenda la ejecución diferida frente a la materialización con ToList/ToArray.

Pipelines de IEnumerable<T> y ejecución diferida es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Concepto de la canalización de LINQ

Canalización = cadena de operadores que transforma una secuencia.

  • Origen: un IEnumerable<T>
  • Operadores: Where, Select, etc.
  • Destino: enumeración (foreach) o materialización (ToList)

Where + Select

Cree una cadena con Where y después Select. La consulta se ejecuta a medida que la enumera.

using System;
using System.Linq;

public class Program
{
  public static void Main(string[] args)
  {
    int[] numbers = new int[] { 1, 2, 3, 4, 5 };

    // Build pipeline: keep even numbers, then square them
    var query = numbers
      .Where(n => n % 2 == 0)
      .Select(n => n * n);

    foreach (int x in query)
    {
      Console.WriteLine(x); // 4, 16
    }
  }
}

Efecto de la ejecución diferida

Ejecución diferida: la consulta se evalúa en el momento de la enumeración, por lo que puede reflejar cambios posteriores en el origen.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
  public static void Main(string[] args)
  {
    List<int> data = new List<int>();
    data.Add(1);
    data.Add(2);

    var evens = data.Where(x => x % 2 == 0); // query is not executed yet

    data.Add(3);
    data.Add(4); // modify source after building query

    foreach (int e in evens)
    {
      Console.WriteLine(e); // prints 2 and 4 because execution is deferred
    }
  }
}

Materialización (ToList)

Utilice ToList/ToArray para materializar la secuencia ahora y evitar cambios posteriores en el origen.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
  public static void Main(string[] args)
  {
    List<string> words = new List<string>();
    words.Add("apple");
    words.Add("banana");

    var longOnes = words.Where(w => w.Length >= 6);
    List<string> snapshot = longOnes.ToList(); // materialize now

    words.Add("pear");     // changes after materialization
    words.Add("cherry");   // length 6, but snapshot is already frozen

    foreach (string w in snapshot)
    {
      Console.WriteLine(w); // prints "banana" only
    }
  }
}

OrderBy + Take

Combine OrderBy, Select y Take/Skip para crear canalizaciones pequeñas y legibles.

using System;
using System.Linq;

public class Program
{
  public static void Main(string[] args)
  {
    int[] nums = new int[] { 5, 1, 4, 2, 3 };

    var firstTwoSortedSquares = nums
      .OrderBy(n => n)   // 1,2,3,4,5
      .Select(n => n * n)
      .Take(2);          // 1,4

    foreach (int x in firstTwoSortedSquares)
    {
      Console.WriteLine(x);
    }
  }
}

Consejos y aspectos problemáticos

Consejos:

  • Las consultas crean un plan; se ejecutan cuando las enumera o las materializa.
  • Materialice con ToList cuando necesite una instantánea estable.
  • Mantenga cada paso pequeño y asígnele un nombre claro.
  • Evite volver a enumerar orígenes costosos; guarde una lista si es necesario.

Regla de la ejecución diferida

Comprobación rápida: con LINQ sobre IEnumerable, ¿cuándo se ejecuta realmente la consulta?

Resumen

Resumen: cree canalizaciones pequeñas de IEnumerable<T> con Where/Select/etc. Recuerde: la ejecución es diferida hasta que itera o llama a ToList/ToArray.

Preguntas frecuentes

¿La lección «Pipelines de IEnumerable<T> y ejecución diferida» es gratis?

Sí — el texto completo de «Pipelines de IEnumerable<T> y ejecución diferida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Pipelines de IEnumerable<T> y ejecución diferida»?

Construya pipelines de LINQ sobre IEnumerable y comprenda la ejecución diferida frente a la materialización con ToList/ToArray. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 3.

¿Cuánto tiempo toma la lección «Pipelines de IEnumerable<T> y ejecución diferida»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Pipelines de IEnumerable y ejecución diferida
  2. Select, Where, OrderBy y Take/Skip
  3. Sintaxis de consultas frente a sintaxis de métodos
← Volver a C# Academy