Func dan Action C#: Delegate Generik, Predicate dan Contohnya

Func dan Action adalah tipe delegate generik yang sudah dideklarasikan .NET untukmu, jadi kamu bisa menyimpan dan mengirim fungsi tanpa harus mendeklarasikan tipe delegate terlebih dahulu. Func mengembalikan nilai; Action tidak mengembalikan apa pun.

using System;

class Program
{
    static void Main()
    {
        Func<int> rollFixed = () => 4;
        Func<decimal, decimal> addTip = bill => bill * 1.15m;
        Func<int, int, bool> canAfford = (budget, price) => budget >= price;

        Action greet = () => Console.WriteLine("Hello!");
        Action<string, int> report = (name, score) => Console.WriteLine($"{name} scored {score}");

        Console.WriteLine(rollFixed());
        Console.WriteLine(addTip(40m));
        Console.WriteLine(canAfford(100, 120));
        greet();
        report("Mia", 87);
    }
}

Output:

4
46.00
False
Hello!
Mia scored 87

Aturan yang perlu diingat: di sebuah Func, argumen tipe terakhir adalah tipe kembalian. Func<int, int, bool> menerima dua int dan mengembalikan sebuah bool. Func<int> tidak menerima apa pun dan mengembalikan sebuah int. Semua argumen tipe sebuah Action adalah parameter.

Keluarganya

Predicate, Comparison dan Converter lebih tua dan muncul di method milik List<T> dan Array: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ memakai Func di semua tempat, itulah sebabnya list.Where(...) dan list.FindAll(...) menerima lambda dengan bentuk yang sama tapi tipe yang berbeda:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var ages = new List<int> { 34, 17, 52, 15, 28 };

        Predicate<int> isMinor = a => a < 18;
        Func<int, bool> isAdult = a => a >= 18;
        Comparison<int> descending = (x, y) => y.CompareTo(x);

        Console.WriteLine(string.Join(", ", ages.FindAll(isMinor)));
        Console.WriteLine(string.Join(", ", ages.Where(isAdult)));

        ages.Sort(descending);
        Console.WriteLine(string.Join(", ", ages));

        List<string> labels = ages.ConvertAll(a => $"{a}y");
        Console.WriteLine(string.Join(" ", labels));
    }
}

Output:

17, 15
34, 52, 28
52, 34, 28, 17, 15
52y 34y 28y 17y 15y

Mengirim fungsi ke method

Parameter Func atau Action membuat pemanggil bisa menyediakan bagian algoritma yang berubah-ubah. Dua bentuk yang umum adalah "jalankan ini dan ukur waktunya" serta "coba ini sampai berhasil":

using System;

class Program
{
    static T Retry<T>(Func<int, T> attempt, int maxTries)
    {
        for (int i = 1; i <= maxTries; i++)
        {
            try
            {
                return attempt(i);
            }
            catch (InvalidOperationException)
            {
                Console.WriteLine($"attempt {i} failed");
            }
        }
        throw new InvalidOperationException("all attempts failed");
    }

    static void Twice(Action work)
    {
        work();
        work();
    }

    static void Main()
    {
        string page = Retry(n =>
        {
            if (n < 3) throw new InvalidOperationException();
            return "<html>ok</html>";
        }, maxTries: 5);
        Console.WriteLine(page);

        int clicks = 0;
        Twice(() => clicks++);
        Console.WriteLine($"clicks: {clicks}");
    }
}

Output:

attempt 1 failed
attempt 2 failed
<html>ok</html>
clicks: 2

Retry adalah method generik, jadi Func<int, T> miliknya bisa mengembalikan apa saja; compiler menyimpulkan T sebagai string dari lambda-nya. Lambda yang dikirim ke Twice mengubah variabel lokal clicks, dan ini berhasil karena lambda menangkap variabelnya sendiri, bukan salinan nilainya.

Method group: mengirim method lewat namanya

Kamu tidak butuh lambda untuk mengisi Func atau Action. Nama method yang sudah ada dengan signature yang cocok (sebuah "method group") bisa langsung dikonversi:

using System;
using System.Linq;

class Program
{
    static bool IsWeekendCode(string day) => day == "sat" || day == "sun";

    static void Main()
    {
        Func<string, int> parse = int.Parse;
        Func<string, bool> weekend = IsWeekendCode;
        Action<string> print = Console.WriteLine;

        string[] quantities = { "3", "10", "7" };
        int total = quantities.Select(int.Parse).Sum();

        print($"parsed: {parse("42") + 1}");
        print($"sat is weekend: {weekend("sat")}");
        print($"total quantity: {total}");
    }
}

Output:

parsed: 43
sat is weekend: True
total quantity: 20

Select(int.Parse) sama dengan Select(s => int.Parse(s)), hanya saja tanpa satu lapisan pemanggilan. Compiler memilih overload yang sesuai dengan tipe tujuannya: int.Parse punya beberapa overload, dan hanya Parse(string) yang cocok dengan Func<string, int>. Kalau compiler tidak bisa menentukan satu pilihan (beberapa overload sama-sama cocok, atau argumen tipe sebuah method generik tidak bisa disimpulkan dari method group), pemanggilannya tidak bisa di-compile, dan lambda yang menuliskan pemanggilannya secara eksplisit akan memperbaikinya.

Method group yang dipakai sebagai Func tetap dijalankan nanti, setiap kali delegate itu dipanggil, sama persis seperti lambda. Bedanya hanya pada cara penulisannya.

Mengembalikan fungsi

Sebuah method bisa membuat dan mengembalikan fungsi. Func yang dikembalikan membawa nilai-nilai yang dipakai untuk membuatnya:

using System;

class Program
{
    static Func<decimal, decimal> PercentOff(decimal percent) =>
        price => price - price * percent / 100m;

    static Func<T, T> Twice<T>(Func<T, T> f) => x => f(f(x));

    static void Main()
    {
        Func<decimal, decimal> blackFriday = PercentOff(30m);
        Func<decimal, decimal> staff = PercentOff(10m);

        Console.WriteLine(blackFriday(200m));
        Console.WriteLine(staff(200m));
        Console.WriteLine(Twice(staff)(200m));
    }
}

Output:

140
180
162

Twice(staff) membuat fungsi baru yang menerapkan diskon karyawan dua kali: 200, lalu 180, lalu 162.

Dictionary berisi fungsi

Menyimpan fungsi di dalam dictionary mengubah switch yang panjang menjadi tabel pencarian. Ini bentuk yang biasa dipakai untuk penangan perintah, kalkulator dan aksi menu, dan entri baru bisa ditambahkan saat program berjalan:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var operations = new Dictionary<string, Func<decimal, decimal, decimal>>
        {
            ["+"] = (a, b) => a + b,
            ["-"] = (a, b) => a - b,
            ["*"] = (a, b) => a * b,
            ["/"] = (a, b) => b == 0 ? throw new DivideByZeroException() : a / b,
        };

        var commands = new Dictionary<string, Action<string>>(StringComparer.OrdinalIgnoreCase)
        {
            ["greet"] = arg => Console.WriteLine($"Hello, {arg}"),
            ["shout"] = arg => Console.WriteLine(arg.ToUpper()),
        };

        string[] inputs = { "12 + 30", "7 * 6", "9 / 0", "2 ^ 3" };
        foreach (string input in inputs)
        {
            string[] p = input.Split(' ');
            Func<decimal, decimal, decimal> op;
            if (!operations.TryGetValue(p[1], out op))
            {
                Console.WriteLine($"{input} = unknown operator");
                continue;
            }
            try
            {
                Console.WriteLine($"{input} = {op(decimal.Parse(p[0]), decimal.Parse(p[2]))}");
            }
            catch (DivideByZeroException)
            {
                Console.WriteLine($"{input} = cannot divide by zero");
            }
        }

        commands["GREET"]("Sam");
        commands["shout"]("done");
    }
}

Output:

12 + 30 = 42
7 * 6 = 42
9 / 0 = cannot divide by zero
2 ^ 3 = unknown operator
Hello, Sam
DONE

Menambah operator cukup dengan satu entri dictionary lagi, tanpa mengubah loop-nya. StringComparer.OrdinalIgnoreCase yang dikirim ke dictionary kedua membuat nama perintah tidak membedakan huruf besar dan kecil.

Fungsi async: Func<Task>, bukan Action

Pada kode async, tipe delegate menentukan apakah pemanggil bisa menunggu pekerjaannya selesai:

Func<Task> save = async () => await File.WriteAllTextAsync("a.txt", "data");
await save();                       // the caller can await it and see its exceptions

Func<int, Task<string>> load = async id => await FetchUserAsync(id);
string user = await load(42);

Action bad = async () => await File.WriteAllTextAsync("a.txt", "data");
bad();                              // async void: fire and forget, exceptions escape

Lambda async yang diberikan ke Action menjadi method async void: tidak ada yang bisa melakukan await padanya, dan exception di dalamnya tidak pernah sampai ke pemanggil. Exception itu dilempar ulang di thread pool (atau di thread UI pada aplikasi desktop), dan biasanya membuat proses crash. Saat kamu menulis method yang menerima pekerjaan async, terimalah Func<Task> (atau Func<Task<T>>).

Kapan mendeklarasikan delegate sendiri

Func dan Action mencukupi sebagian besar kebutuhan. Deklarasikan tipe delegate bernama saat:

• Signature-nya punya parameter ref, out atau in. Func tidak bisa menyatakannya, jadi fungsi bergaya TryParse butuh delegate bool TryParser<T>(string text, out T value);.
• Namanya menjelaskan sebuah peran di API publik. delegate bool Validator(string input) di signature sebuah method memberi informasi lebih banyak daripada Func<string, bool>, dan nama parameternya muncul di IntelliSense.
• Kamu butuh parameter params, yang juga tidak bisa dimiliki delegate generik.

Event adalah tempat lain di mana tipe delegate kustom masih muncul, walaupun EventHandler<TEventArgs> bawaan sudah mencakup sebagian besarnya. Halaman delegate membahas cara mendeklarasikan dan menggabungkan tipe delegate.