0Pricing
C# Academy · Lektion

Tipps zur Komponierbarkeit

Halten Sie LINQ komponierbar: Verwenden Sie kleine, reine Prädikate und Transformationen, kombinieren Sie Delegates, ergänzen Sie kleine Erweiterungshelfer und geben Sie IEnumerable -Pipelines zurück.

Tipps zur Komponierbarkeit ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Überblick über zusammensetzbares LINQ

Ziel: LINQ einfach erweiterbar machen.

  • Schreiben Sie kleine, reine Prädikate und Transformationen.
  • Setzen Sie Funktionen zusammen (ohne Seiteneffekte).
  • Fügen Sie kleine Erweiterungshilfen hinzu.
  • Geben Sie IEnumerable<T>-Pipelines zurück.

Wiederverwendbare reine Hilfsmethoden

Lagern Sie kleine reine Methoden aus und übergeben Sie sie als Methodengruppen. Wiederverwendung hält Pipelines kurz und gut lesbar.

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

Prädikate zusammensetzen

Erstellen Sie neue Prädikate, indem Sie kleinere Prädikate zusammensetzen. Dadurch bleibt die Logik testbar und wiederverwendbar.

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

Lesbare Erweiterungen

Fügen Sie eine kleine Erweiterung hinzu, um die Absicht auszudrücken (z. B. WhereNot). Halten Sie sie einfach und frei von Seiteneffekten.

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

Wiederverwendbare Pipeline-Hilfen

Stellen Sie wiederverwendbare IEnumerable<T>-Hilfen bereit. Aufrufer können die Verkettung fortsetzen (OrderBy, Take usw.).

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

Checkliste für Zusammensetzbarkeit

Tipps:

  • Bevorzugen Sie reine Hilfsmethoden; vermeiden Sie Seiteneffekte innerhalb von Select/Where.
  • Setzen Sie Prädikate und Transformationen zusammen und benennen Sie sie sinnvoll.
  • Geben Sie aus Hilfsmethoden IEnumerable<T> zurück, damit Aufrufer die Kette erweitern können.
  • Materialisieren Sie spät; vermeiden Sie ToList mitten in der Kette, sofern es nicht erforderlich ist.

Bewährte Vorgehensweise für Zusammensetzbarkeit

Kurzer Check: Welche Vorgehensweise sorgt am besten dafür, dass LINQ-Pipelines zusammensetzbar und testbar bleiben?

Zusammenfassung

Zusammenfassung: Lagern Sie kleine, reine Hilfsmethoden aus, setzen Sie Prädikate zusammen, fügen Sie kleine Erweiterungen hinzu und geben Sie Pipelines zurück, damit Aufrufer die Verkettung fortsetzen können.

Häufig gestellte Fragen

Ist die Lektion „Tipps zur Komponierbarkeit“ kostenlos?

Ja — der vollständige Text von „Tipps zur Komponierbarkeit“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Tipps zur Komponierbarkeit“?

Halten Sie LINQ komponierbar: Verwenden Sie kleine, reine Prädikate und Transformationen, kombinieren Sie Delegates, ergänzen Sie kleine Erweiterungshelfer und geben Sie IEnumerable -Pipelines zurück. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.

Wie lange dauert die Lektion „Tipps zur Komponierbarkeit“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. GroupBy, Join, Aggregate und Projektionen (anonyme Typen)
  2. Materialisierung (ToList, ToDictionary) und Performance-Hinweise
  3. Tipps zur Komponierbarkeit
← Zurück zu C# Academy