Func và Action C#: delegate generic, Predicate và ví dụ

Func và Action là các kiểu delegate generic được .NET khai báo sẵn cho bạn, nhờ vậy bạn có thể lưu và truyền hàm mà không phải khai báo kiểu delegate trước. Func trả về một giá trị; Action không trả về gì.

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

Đầu ra:

4
46.00
False
Hello!
Mia scored 87

Quy tắc cần nhớ: trong Func, đối số kiểu cuối cùng là kiểu trả về. Func<int, int, bool> nhận hai int và trả về một bool. Func<int> không nhận gì và trả về một int. Các đối số kiểu của Action đều là tham số.

Họ delegate có sẵn

Predicate, Comparison và Converter ra đời sớm hơn và xuất hiện trong các phương thức của List<T> và Array: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ thì dùng Func ở mọi nơi, vì vậy list.Where(...) và list.FindAll(...) nhận lambda cùng dạng nhưng khác kiểu:

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

Đầu ra:

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

Truyền hàm vào phương thức

Một tham số Func hoặc Action cho phép nơi gọi cung cấp phần thay đổi của một thuật toán. Hai dạng hay gặp là "chạy cái này và đo thời gian" và "thử cái này đến khi thành công":

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

Đầu ra:

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

Retry là generic, nên Func<int, T> của nó trả về được bất cứ thứ gì; trình biên dịch suy ra T là string từ lambda. Lambda truyền vào Twice thay đổi biến cục bộ clicks, điều này được vì lambda bắt (capture) chính biến đó chứ không phải một bản sao giá trị của nó.

Method group: truyền phương thức bằng tên

Bạn không cần lambda để gán cho Func hay Action. Tên của một phương thức có sẵn với chữ ký khớp (gọi là "method group") được chuyển đổi trực tiếp:

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

Đầu ra:

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

Select(int.Parse) tương đương Select(s => int.Parse(s)), chỉ bớt đi một lớp lời gọi. Trình biên dịch chọn overload khớp với kiểu đích: int.Parse có nhiều overload, và chỉ Parse(string) khớp với Func<string, int>. Khi trình biên dịch không chốt được một overload (nhiều overload khớp ngang nhau, hoặc không suy ra được đối số kiểu của một phương thức generic từ method group), lời gọi sẽ không biên dịch, và một lambda viết rõ lời gọi sẽ khắc phục được.

Một method group dùng làm Func vẫn chạy về sau, mỗi khi delegate được gọi, giống hệt một lambda. Khác biệt chỉ nằm ở cách viết.

Trả về hàm

Một phương thức có thể tạo ra và trả về một hàm. Func được trả về mang theo các giá trị đã dùng để tạo ra nó:

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

Đầu ra:

140
180
162

Twice(staff) tạo một hàm mới áp dụng giảm giá cho nhân viên hai lần: 200, rồi 180, rồi 162.

Từ điển chứa hàm

Lưu hàm trong một từ điển biến một switch dài thành một bảng tra cứu. Đây là dạng thường dùng cho trình xử lý lệnh, máy tính và các hành động trong menu, và có thể thêm mục mới lúc chương trình đang chạy:

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

Đầu ra:

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

Thêm một toán tử chỉ là thêm một mục vào từ điển, không phải sửa vòng lặp. StringComparer.OrdinalIgnoreCase truyền vào từ điển thứ hai giúp tên lệnh không phân biệt hoa thường.

Hàm async: Func<Task>, không phải Action

Với code async, kiểu delegate quyết định nơi gọi có chờ được công việc hay không:

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

Một lambda async gán cho Action sẽ thành một phương thức async void: không gì await được nó, và ngoại lệ bên trong không bao giờ đến được nơi gọi. Ngoại lệ đó bị ném lại trên thread pool (hoặc trên luồng giao diện trong ứng dụng desktop), nơi nó thường làm sập tiến trình. Khi viết một phương thức nhận công việc async, hãy nhận Func<Task> (hoặc Func<Task<T>>).

Khi nào nên tự khai báo delegate

Func và Action đáp ứng phần lớn nhu cầu. Hãy khai báo một kiểu delegate có tên khi:

• Chữ ký có tham số ref, out hoặc in. Func không biểu diễn được chúng, nên một hàm kiểu TryParse cần delegate bool TryParser<T>(string text, out T value);.
• Cái tên ghi lại vai trò trong một API public. delegate bool Validator(string input) trong chữ ký phương thức nói rõ hơn Func<string, bool>, và tên tham số của nó hiện ra trong IntelliSense.
• Bạn cần một tham số params, điều mà delegate generic cũng không làm được.

Event là nơi còn lại vẫn thấy kiểu delegate tự định nghĩa, dù EventHandler<TEventArgs> có sẵn đã đáp ứng phần lớn trường hợp. Trang delegate trình bày cách khai báo và kết hợp các kiểu delegate.