C# Academy · Aula

Esteiras de IEnumerable<T>; execução adiada

Crie esteiras de LINQ sobre IEnumerable e veja a diferença entre execução adiada e materialização com ToList/ToArray.

Esteiras de IEnumerable<T>; execução adiada é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.

Ideia de fluxo do LINQ

Fluxo = cadeia de operadores que transforma uma sequência.

Origem: um IEnumerable<T>
Operadores: Where, Select etc.
Destino: enumeração (foreach) ou materialização (ToList)

Where + Select

Crie uma cadeia com Where e depois Select. A consulta é executada à medida que o utilizador itera.

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
    }
  }
}

Efeito da execução adiada

Execução adiada: a consulta é avaliada no momento da enumeração, portanto alterações posteriores na origem podem ser percebidas.

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
    }
  }
}

Materialização (ToList)

Utilize ToList/ToArray para materializar a sequência agora e evitar alterações posteriores na origem.

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 e Take/Skip para criar fluxos pequenos e fáceis de ler.

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

Dicas e armadilhas

Dicas:

As consultas constroem um plano; são executadas quando o utilizador as enumera ou materializa.
Materialize com ToList quando precisar de uma fotografia estável.
Mantenha cada etapa pequena e atribua-lhe um nome claro.
Evite enumerar novamente fontes dispendiosas; armazene uma lista, se necessário.

Regra da execução adiada

Verificação rápida: com LINQ sobre IEnumerable<T>, quando é que a consulta é realmente executada?

Recapitulação

Recapitulação: crie fluxos pequenos de IEnumerable<T> com Where/Select/etc. Lembre-se: a execução é adiada até iterar ou chamar ToList/ToArray.

Perguntas Frequentes

A aula “Esteiras de IEnumerable<T>; execução adiada” é grátis?

Sim — o texto completo de “Esteiras de IEnumerable<T>; execução adiada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.

O que vou aprender em “Esteiras de IEnumerable<T>; execução adiada”?

Crie esteiras de LINQ sobre IEnumerable e veja a diferença entre execução adiada e materialização com ToList/ToArray. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “Esteiras de IEnumerable<T>; execução adiada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Esteiras de IEnumerable ; execução adiada
Select, Where, OrderBy, Take/Skip
Sintaxe de consulta versus sintaxe de método

← Voltar para C# Academy