C# Academy · Lekcja

Potoki IEnumerable<T> i odroczone wykonanie

Proszę budować potoki LINQ dla IEnumerable oraz poznać różnicę między odroczonym wykonaniem a materializacją za pomocą ToList/ToArray.

Potoki IEnumerable<T> i odroczone wykonanie to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Idea potoku LINQ

Potok = łańcuch operatorów przekształcających sekwencję.

Źródło: obiekt IEnumerable<T>
Operatory: Where, Select itd.
Punkt końcowy: enumeracja (foreach) lub materializacja (ToList)

Where + Select

Utwórz łańcuch najpierw z Where, a następnie z Select. Zapytanie jest wykonywane podczas iterowania.

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

Skutek odroczonego wykonania

Odroczone wykonanie: zapytanie jest obliczane w momencie enumeracji, dlatego mogą być widoczne późniejsze zmiany w źródle.

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

Materializacja (ToList)

Należy użyć ToList/ToArray, aby zmaterializować sekwencję w tym momencie i uniknąć późniejszych zmian w źródle.

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

Połącz OrderBy, Select oraz Take/Skip, aby utworzyć małe, czytelne potoki.

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

Wskazówki i pułapki

Wskazówki:

Zapytania tworzą plan; są wykonywane podczas enumeracji lub materializacji.
Należy materializować za pomocą ToList, gdy potrzebna jest stabilna migawka.
Każdy krok powinien być mały i jasno nazwany.
Należy unikać ponownej enumeracji kosztownych źródeł; w razie potrzeby należy przechować listę.

Reguła odroczonego wykonania

Szybkie sprawdzenie: W przypadku LINQ używającego IEnumerable kiedy zapytanie jest faktycznie wykonywane?

Podsumowanie

Podsumowanie: Twórz małe potoki IEnumerable<T> za pomocą Where/Select/itd. Pamiętaj: wykonanie jest odroczone do momentu iterowania lub wywołania ToList/ToArray.

Często zadawane pytania

Czy lekcja „Potoki IEnumerable<T> i odroczone wykonanie” jest bezpłatna?

Tak — pełny tekst „Potoki IEnumerable<T> i odroczone wykonanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Potoki IEnumerable<T> i odroczone wykonanie”?

Proszę budować potoki LINQ dla IEnumerable oraz poznać różnicę między odroczonym wykonaniem a materializacją za pomocą ToList/ToArray. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Potoki IEnumerable<T> i odroczone wykonanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Potoki IEnumerable i odroczone wykonanie
Select, Where, OrderBy, Take/Skip
Składnia zapytań a składnia metod

← Powrót do C# Academy