0Pricing
C# Academy · Leçon

Conseils de composabilité

Préservez la composabilité de LINQ : utilisez de petits prédicats et transformations purs, composez des délégués, ajoutez de minuscules assistants d’extension et renvoyez des pipelines IEnumerable .

Conseils de composabilité est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Vue d’ensemble de LINQ composable

Objectif : faciliter l’évolution de LINQ.

  • Écrivez de petits prédicats et transformateurs purs
  • Composez des fonctions (sans effets secondaires)
  • Ajoutez de petits assistants d’extension
  • Renvoyez des chaînes IEnumerable<T>

Réutiliser des assistants purs

Extrayez de petites méthodes pures et transmettez-les comme groupes de méthodes. La réutilisation permet de garder les chaînes courtes et lisibles.

using System;
using System.Linq;

public class Program
{
  static bool IsEven(int n) { return n % 2 == 0; }   // pure predicate
  static int Square(int n) { return n * n; }         // pure transform

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

    var q = xs
      .Where(IsEven)     // reuse predicate
      .Select(Square);   // reuse transform

    foreach (int v in q) Console.WriteLine(v); // 4 16 36
  }
}

Composer des prédicats

Créez de nouveaux prédicats en les composant à partir de prédicats plus petits. La logique reste ainsi testable et réutilisable.

using System;
using System.Linq;

public class Program
{
  // Return a predicate n > threshold
  static Func<int, bool> GreaterThan(int threshold)
  {
    return delegate(int n) { return n > threshold; };
  }

  // Combine two predicates with AND
  static Func<int, bool> And(Func<int, bool> a, Func<int, bool> b)
  {
    return delegate(int n) { return a(n) && b(n); };
  }

  static bool IsEven(int n) { return n % 2 == 0; }

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

    Func<int, bool> gt2 = GreaterThan(2);
    Func<int, bool> evenAndGt2 = And(IsEven, gt2);

    var q = xs.Where(evenAndGt2); // even and > 2 => 4,6

    foreach (int v in q) Console.WriteLine(v);
  }
}

Extensions lisibles

Ajoutez une petite extension pour exprimer l’intention (par exemple, WhereNot). Gardez-la simple et sans effets secondaires.

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

public static class LinqEx
{
  public static IEnumerable<T> WhereNot<T>(this IEnumerable<T> src, Func<T, bool> predicate)
  {
    foreach (T item in src)
    {
      if (!predicate(item)) yield return item;
    }
  }
}

public class Program
{
  static bool IsVowel(char c)
  {
    char x = Char.ToLower(c);
    return x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u';
  }

  public static void Main(string[] args)
  {
    char[] letters = new char[] { 'a', 'b', 'c', 'e', 'i' };

    var consonants = letters.WhereNot(IsVowel);

    foreach (char c in consonants) Console.WriteLine(c); // b, c
  }
}

Assistants de chaîne réutilisables

Exposez des assistants IEnumerable<T> réutilisables. Le code appelant peut continuer à composer (OrderBy, Take, etc.).

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

public class Program
{
  static bool IsEven(int n) { return n % 2 == 0; }
  static int Square(int n) { return n * n; }

  // Reusable pipeline helper: filter evens and square
  public static IEnumerable<int> SquaresOfEvens(IEnumerable<int> xs)
  {
    foreach (int x in xs)
    {
      if (IsEven(x)) yield return Square(x);
    }
  }

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

    var pipeline = SquaresOfEvens(data); // composable
    var topTwo = pipeline.OrderByDescending(x => x).Take(2);

    foreach (int v in topTwo) Console.WriteLine(v); // 36, 16
  }
}

Liste de contrôle de la composabilité

Conseils :

  • Préférez les assistants purs ; évitez les effets secondaires dans Select/Where.
  • Composez les prédicats et les transformations ; donnez-leur de bons noms.
  • Renvoyez IEnumerable<T> depuis les assistants afin que le code appelant puisse prolonger la chaîne.
  • Matérialisez tardivement ; évitez ToList au milieu de la chaîne, sauf nécessité.

Bonne pratique pour la composabilité

Vérification rapide : quelle pratique permet le mieux de conserver des chaînes LINQ composables et testables ?

Récapitulatif

Récapitulatif : extrayez de petits assistants purs, composez les prédicats, ajoutez de petites extensions et renvoyez des chaînes afin que le code appelant puisse continuer à les enchaîner.

Questions Fréquemment Posées

La leçon « Conseils de composabilité » est-elle gratuite ?

Oui — le texte complet de « Conseils de composabilité » 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 « Conseils de composabilité » ?

Préservez la composabilité de LINQ : utilisez de petits prédicats et transformations purs, composez des délégués, ajoutez de minuscules assistants d’extension et renvoyez des pipelines IEnumerable . 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 3 sur 3.

Combien de temps prend la leçon « Conseils de composabilité » ?

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. GroupBy, Join, Aggregate et projections (types anonymes)
  2. Matérialisation (ToList, ToDictionary) et remarques sur les performances
  3. Conseils de composabilité
← Retour à C# Academy