0Pricing
C# Academy · Leçon

Pipelines IEnumerable<T> et exécution différée

Construisez des pipelines LINQ sur IEnumerable et observez la différence entre l’exécution différée et la matérialisation avec ToList/ToArray.

Pipelines IEnumerable<T> et exécution différée est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Idée de pipeline LINQ

pipeline = chaîne d’opérateurs qui transforme une séquence.

  • Source : un IEnumerable<T>
  • Opérateurs : Where, Select, etc.
  • Destination : énumération (foreach) ou matérialisation (ToList)

Where + Select

Créez une chaîne avec Where, puis Select. La requête s’exécute au fur et à mesure de l’itération.

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

Effet de l’exécution différée

Exécution différée : la requête est évaluée au moment de l’énumération ; les modifications ultérieures de la source peuvent donc être visibles.

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

Matérialisation (ToList)

Utilisez ToList/ToArray pour matérialiser la séquence dès maintenant et éviter les modifications ultérieures de la source.

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

Combinez OrderBy, Select et Take/Skip pour créer des chaînes courtes et lisibles.

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

Conseils et pièges

Conseils :

  • Les requêtes construisent un plan ; elles s’exécutent lorsque vous les énumérez ou les matérialisez.
  • Matérialisez avec ToList lorsque vous avez besoin d’un instantané stable.
  • Gardez chaque étape petite et donnez-lui un nom explicite.
  • Évitez de réénumérer des sources coûteuses ; stockez une liste si nécessaire.

Règle de l’exécution différée

Vérification rapide : avec LINQ sur IEnumerable<T>, quand la requête s’exécute-t-elle réellement ?

Récapitulatif

Récapitulatif : créez de petites chaînes IEnumerable<T> avec Where/Select/etc. N’oubliez pas : l’exécution est différée jusqu’à ce que vous itériez ou appeliez ToList/ToArray.

Questions Fréquemment Posées

La leçon « Pipelines IEnumerable<T> et exécution différée » est-elle gratuite ?

Oui — le texte complet de « Pipelines IEnumerable<T> et exécution différée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Pipelines IEnumerable<T> et exécution différée » ?

Construisez des pipelines LINQ sur IEnumerable et observez la différence entre l’exécution différée et la matérialisation avec ToList/ToArray. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « Pipelines IEnumerable<T> et exécution différée » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pipelines IEnumerable et exécution différée
  2. Select, Where, OrderBy et Take/Skip
  3. Syntaxe de requête et syntaxe de méthode
← Retour à C# Academy