C# Academy · Lezione

Pipeline IEnumerable<T>; esecuzione differita

Costruite pipeline LINQ su IEnumerable e osservate la differenza tra esecuzione differita e materializzazione con ToList/ToArray.

Pipeline IEnumerable<T>; esecuzione differita è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.

Idea della pipeline LINQ

Pipeline = catena di operatori che trasforma una sequenza.

Sorgente: un IEnumerable<T>
Operatori: Where, Select, ecc.
Destinazione: enumerazione (foreach) o materializzazione (ToList)

Where + Select

Crei una catena con Where seguito da Select. La query viene eseguita durante l'iterazione.

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

Effetto dell'esecuzione differita

Esecuzione differita: la query viene valutata al momento dell'enumerazione, quindi le modifiche successive alla sorgente possono essere rilevate.

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

Materializzazione (ToList)

Utilizzi ToList/ToArray per materializzare subito la sequenza ed evitare che le modifiche successive alla sorgente la influenzino.

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

Combini OrderBy, Select e Take/Skip per creare pipeline brevi e leggibili.

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

Suggerimenti e insidie

Suggerimenti:

Le query costruiscono un piano; vengono eseguite quando le enumera o le materializza.
Materializzi con ToList quando serve un'istantanea stabile.
Mantenga ogni passaggio piccolo e gli assegni un nome chiaro.
Eviti di enumerare nuovamente sorgenti costose; se necessario, conservi una lista.

Regola dell'esecuzione differita

Controllo rapido: con LINQ su IEnumerable, quando viene eseguita effettivamente la query?

Riepilogo

Riepilogo: costruisca piccole pipeline IEnumerable<T> con Where/Select/ecc. Ricordi che l'esecuzione è differita fino all'iterazione o alla chiamata di ToList/ToArray.

Domande Frequenti

La lezione «Pipeline IEnumerable<T>; esecuzione differita» è gratuita?

Sì — il testo completo di «Pipeline IEnumerable<T>; esecuzione differita» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.

Cosa imparerò in «Pipeline IEnumerable<T>; esecuzione differita»?

Costruite pipeline LINQ su IEnumerable e osservate la differenza tra esecuzione differita e materializzazione con ToList/ToArray. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «Pipeline IEnumerable<T>; esecuzione differita»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Pipeline IEnumerable ; esecuzione differita
Select, Where, OrderBy, Take/Skip
Sintassi di query e sintassi dei metodi

← Torna a C# Academy