Akademi C# · Pelajaran

Petua kebolehkomposisian

Pastikan LINQ boleh digubah: gunakan predikat/transformasi tulen yang kecil, gubah delegate, tambah pembantu sambungan yang ringkas, dan kembalikan saluran paip IEnumerable .

Pelajaran 3 daripada 38 langkah

Petua kebolehkomposisian ialah pelajaran Akademi C# percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Akademi C#, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Akademi C# merangkumi sejumlah 3 pelajaran.

Gambaran keseluruhan LINQ boleh gubah

Matlamat: Jadikan LINQ mudah dikembangkan.

Tulis predikat/transformasi kecil dan tulen
Gubah fungsi (tanpa kesan sampingan)
Tambahkan pembantu pelanjutan yang kecil
Kembalikan rantaian IEnumerable<T>

Pembantu tulen yang boleh diguna semula

Ekstrak kaedah kecil yang tulen dan hantarkannya sebagai kumpulan kaedah. Penggunaan semula memastikan rantaian pendek dan mudah dibaca.

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

Menggubah predikat

Bina predikat baharu dengan menggabungkan predikat yang lebih kecil. Ini memastikan logik mudah diuji dan digunakan semula.

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

Pelanjutan yang mudah dibaca

Tambahkan pelanjutan kecil untuk menyatakan tujuan, contohnya WhereNot. Pastikan ia ringkas dan bebas daripada kesan sampingan.

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

Pembantu rantaian boleh guna semula

Sediakan pembantu IEnumerable<T> yang boleh digunakan semula. Pemanggil boleh terus menggubahnya (OrderBy, Take dan sebagainya).

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

Senarai semak kebolehgubahan

Petua:

Utamakan pembantu tulen; elakkan kesan sampingan dalam Select/Where.
Gubah predikat dan transformasi; namakannya dengan baik.
Kembalikan IEnumerable<T> daripada pembantu supaya pemanggil boleh melanjutkan rantaian.
Realisasikan lewat; elakkan ToList di tengah-tengah kecuali diperlukan.

Amalan terbaik untuk kebolehgubahan

Pemeriksaan ringkas: Apakah amalan yang paling baik untuk memastikan rantaian LINQ boleh digubah dan diuji?

Jawab dalam pelajaran interaktif

Imbas kembali

Imbas kembali: Ekstrak pembantu kecil yang tulen, gubah predikat, tambahkan pelanjutan kecil dan kembalikan rantaian supaya pemanggil boleh terus merangkaikannya.

Percuma untuk bermula

Pelajari C# dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 93
Pelajaran: 346

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Petua kebolehkomposisian” percuma?

Ya — teks penuh “Petua kebolehkomposisian” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Akademi C#, tingkat taraf kepada CoddyKit PRO. Kursus Akademi C# merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Petua kebolehkomposisian”?

Pastikan LINQ boleh digubah: gunakan predikat/transformasi tulen yang kecil, gubah delegate, tambah pembantu sambungan yang ringkas, dan kembalikan saluran paip IEnumerable . Anda berlatih Akademi C# menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Akademi C#?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Akademi C# di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Petua kebolehkomposisian” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Akademi C# ini?

Ya. Setiap pelajaran Akademi C# menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

GroupBy, Join, Aggregate, unjuran (jenis tanpa nama)
Pembentukan koleksi (ToList, ToDictionary) & nota prestasi
Petua kebolehkomposisian

← Kembali ke Akademi C#