Tips för komponerbarhet
Håll LINQ komponerbar: använd små rena predikat och omvandlingar, komponera delegates, lägg till små extension helpers och returnera IEnumerable -pipelines.
Tips för komponerbarhet är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 3 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 3 lektioner.
Översikt över komponerbar LINQ
Mål: Gör LINQ enkel att bygga ut.
- Skriv små rena predikat/transformeringar
- Komponera funktioner (utan sidoeffekter)
- Lägg till små tillägg
- Returnera IEnumerable<T>-pipelines
Återanvänd rena hjälpfunktioner
Extrahera små rena metoder och skicka in dem som metodgrupper. Återanvändning håller pipelines korta och lättlästa.
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
}
}
Komponera predikat
Skapa nya predikat genom att komponera mindre predikat. Det gör logiken testbar och återanvändbar.
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);
}
}
Lättlästa tillägg
Lägg till ett litet tillägg för att uttrycka avsikten (t.ex. WhereNot). Håll det enkelt och fritt från sidoeffekter.
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
}
}
Återanvändbara pipelinehjälpare
Exponera återanvändbara IEnumerable<T>-hjälpfunktioner. Den som anropar dem kan fortsätta komponera (OrderBy, Take osv.).
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
}
}
Checklista för komponerbarhet
Tips:
- Föredra rena hjälpfunktioner; undvik sidoeffekter i Select/Where.
- Komponera predikat och transformeringar; namnge dem tydligt.
- Returnera IEnumerable<T> från hjälpfunktioner så att anropare kan bygga ut kedjan.
- Materialisera sent; undvik ToList mitt i kedjan om det inte behövs.
Bästa praxis för komponerbarhet
Sammanfattning
Sammanfattning: Extrahera små rena hjälpfunktioner, komponera predikat, lägg till små tillägg och returnera pipelines så att anropare kan fortsätta bygga kedjor.
Lär dig C# med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 93
- Lektioner
- 346
Vanliga frågor
Är lektionen ”Tips för komponerbarhet” gratis?
Ja – hela texten till ”Tips för komponerbarhet” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 3 lektioner.
Vad lär jag mig i ”Tips för komponerbarhet”?
Håll LINQ komponerbar: använd små rena predikat och omvandlingar, komponera delegates, lägg till små extension helpers och returnera IEnumerable -pipelines. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig C# Academy?
Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 3.
Hur lång tid tar lektionen ”Tips för komponerbarhet”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här C# Academy-lektionen?
Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- GroupBy, Join, Aggregate och projektioner (anonyma typer)
- Materialisering (ToList, ToDictionary) och prestandaanmärkningar
- Tips för komponerbarhet