0Pricing
C# Academy · Lección

Consejos de composabilidad

Mantenga LINQ componible: use predicados y transformaciones puras y pequeñas, componga delegates, añada helpers de extensión mínimos y devuelva pipelines de IEnumerable .

Consejos de composabilidad es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Descripción general de LINQ componible

Objetivo: facilite la ampliación de LINQ.

  • Escriba predicados y transformaciones pequeños y puros
  • Componga funciones (sin efectos secundarios)
  • Añada pequeños auxiliares de extensión
  • Devuelva canalizaciones de IEnumerable<T>

Reutilización de auxiliares puros

Extraiga métodos puros pequeños y páselos como grupos de métodos. La reutilización mantiene las canalizaciones cortas y legibles.

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

Composición de predicados

Construya predicados nuevos componiendo otros más pequeños. Esto mantiene la lógica fácil de probar y reutilizar.

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

Extensiones legibles

Añada una pequeña extensión para expresar la intención (por ejemplo, WhereNot). Manténgala sencilla y sin efectos secundarios.

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

Auxiliares de canalización reutilizables

Exponga auxiliares reutilizables de IEnumerable<T>. Los llamadores pueden seguir componiendo (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
  }
}

Lista de comprobación de la componibilidad

Consejos:

  • Prefiera auxiliares puros; evite efectos secundarios dentro de Select/Where.
  • Componga predicados y transformaciones; asígneles buenos nombres.
  • Devuelva IEnumerable<T> desde los auxiliares para que los llamadores puedan ampliar la cadena.
  • Materialice al final; evite ToList en mitad de la cadena salvo que sea necesario.

Práctica recomendada para la componibilidad

Comprobación rápida: ¿qué práctica ayuda más a mantener las canalizaciones de LINQ componibles y fáciles de probar?

Resumen

Resumen: extraiga pequeños auxiliares puros, componga predicados, añada pequeñas extensiones y devuelva canalizaciones para que los llamadores puedan seguir encadenándolas.

Preguntas frecuentes

¿La lección «Consejos de composabilidad» es gratis?

Sí — el texto completo de «Consejos de composabilidad» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Consejos de composabilidad»?

Mantenga LINQ componible: use predicados y transformaciones puras y pequeñas, componga delegates, añada helpers de extensión mínimos y devuelva pipelines de IEnumerable . Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Consejos de composabilidad»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. GroupBy, Join, Aggregate y proyecciones (tipos anónimos)
  2. Materialización (ToList, ToDictionary) y notas de rendimiento
  3. Consejos de composabilidad
← Volver a C# Academy