0Pricing
C# Academy · Lekcja

Wskazówki dotyczące kompozycyjności

Proszę zachowywać kompozycyjność LINQ: używać małych, czystych predykatów i przekształceń, komponować delegaty, dodawać niewielkie metody rozszerzające oraz zwracać potoki IEnumerable .

Wskazówki dotyczące kompozycyjności to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.

Przegląd komponowalnego LINQ

Cel: Ułatwić rozbudowę LINQ.

  • Pisz małe, czyste predykaty i przekształcenia
  • Komponuj funkcje (bez efektów ubocznych)
  • Dodawaj małe pomocnicze metody rozszerzające
  • Zwracaj potoki IEnumerable<T>

Ponowne użycie czystych metod pomocniczych

Wyodrębnij małe czyste metody i przekazuj je jako grupy metod. Ponowne użycie pozwala zachować krótkie i czytelne potoki.

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

Komponowanie predykatów

Twórz nowe predykaty przez komponowanie mniejszych. Dzięki temu logika pozostaje łatwa do testowania i ponownego użycia.

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

Czytelne metody rozszerzające

Dodaj małą metodę rozszerzającą, aby wyrazić intencję (np. WhereNot). Zachowaj jej prostotę i brak efektów ubocznych.

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

Wielokrotnego użytku pomocnicze metody potoków

Udostępniaj pomocnicze metody wielokrotnego użytku zwracające IEnumerable<T>. Kod wywołujący może nadal tworzyć łańcuch (OrderBy, Take itd.).

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 kontrolna komponowalności

Wskazówki:

  • Preferuj czyste metody pomocnicze; unikaj efektów ubocznych wewnątrz Select/Where.
  • Komponuj predykaty i przekształcenia; nadaj im dobre nazwy.
  • Zwracaj IEnumerable<T> z metod pomocniczych, aby wywołujący mogli rozszerzać łańcuch.
  • Materializuj późno; unikaj ToList w środku, chyba że jest to konieczne.

Najlepsza praktyka komponowalności

Szybkie sprawdzenie: Jaka praktyka najlepiej pozwala zachować możliwość komponowania i testowania potoków LINQ?

Podsumowanie

Podsumowanie: Wyodrębniaj małe, czyste metody pomocnicze, komponuj predykaty, dodawaj małe metody rozszerzające i zwracaj potoki, aby wywołujący mogli nadal tworzyć łańcuchy.

Często zadawane pytania

Czy lekcja „Wskazówki dotyczące kompozycyjności” jest bezpłatna?

Tak — pełny tekst „Wskazówki dotyczące kompozycyjności” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Wskazówki dotyczące kompozycyjności”?

Proszę zachowywać kompozycyjność LINQ: używać małych, czystych predykatów i przekształceń, komponować delegaty, dodawać niewielkie metody rozszerzające oraz zwracać potoki IEnumerable . Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Wskazówki dotyczące kompozycyjności”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. GroupBy, Join, Aggregate i projekcje (typy anonimowe)
  2. Materializacja (ToList, ToDictionary) i uwagi dotyczące wydajności
  3. Wskazówki dotyczące kompozycyjności
← Powrót do C# Academy