Consigli sulla componibilità
Mantenete componibile LINQ: usate predicati e trasformazioni pure di piccole dimensioni, componete delegate, aggiungete piccoli helper di estensione e restituite pipeline IEnumerable .
Consigli sulla componibilità è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Panoramica di LINQ componibile
Obiettivo: rendere LINQ facile da estendere.
- Scriva predicati e trasformazioni piccoli e puri
- Componga funzioni (senza effetti collaterali)
- Aggiunga piccoli helper di estensione
- Restituisca pipeline IEnumerable<T>
Riutilizzo di helper puri
Estragga piccoli metodi puri e li passi come gruppi di metodi. Il riutilizzo mantiene le pipeline brevi e leggibili.
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
}
}
Composizione dei predicati
Costruisca nuovi predicati componendo predicati più piccoli. In questo modo la logica rimane facile da testare e riutilizzare.
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);
}
}
Estensioni leggibili
Aggiunga una piccola estensione per esprimere l'intento (ad esempio, WhereNot). La mantenga semplice e priva di effetti collaterali.
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
}
}
Helper riutilizzabili per le pipeline
Esponga helper riutilizzabili per IEnumerable<T>. I chiamanti possono continuare a comporre la pipeline (OrderBy, Take, ecc.).
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
}
}
Checklist della componibilità
Suggerimenti:
- Preferisca helper puri; eviti effetti collaterali all'interno di Select/Where.
- Componga predicati e trasformazioni e assegni loro nomi appropriati.
- Restituisca IEnumerable<T> dagli helper, così i chiamanti possono estendere la catena.
- Materializzi tardi; eviti ToList nel mezzo, salvo necessità.
Buona pratica per la componibilità
Riepilogo
Riepilogo: estragga piccoli helper puri, componga i predicati, aggiunga piccole estensioni e restituisca pipeline che i chiamanti possano continuare a concatenare.
Domande Frequenti
La lezione «Consigli sulla componibilità» è gratuita?
Sì — il testo completo di «Consigli sulla componibilità» è 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 «Consigli sulla componibilità»?
Mantenete componibile LINQ: usate predicati e trasformazioni pure di piccole dimensioni, componete delegate, aggiungete piccoli helper di estensione e restituite pipeline IEnumerable . 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 3 di 3.
Quanto tempo richiede la lezione «Consigli sulla componibilità»?
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
- GroupBy, Join, Aggregate, proiezioni (tipi anonimi)
- Materializzazione (ToList, ToDictionary) e note sulle prestazioni
- Consigli sulla componibilità