מה זה Predicate ב-C#?

טיפוס delegate שמקבל T ומחזיר bool, אותה צורה כמו Func . הוא קדם ל-Func ומשמש את List .Find, FindAll, RemoveAll, Exists ו-Array.Find. שני הטיפוסים לא מומרים זה לזה, אבל lambda מומרת לכל אחד מהם.

תיעוד C# עם דוגמאות להרצה: Func ו-Action

Q: מה ההבדל בין Func ל-Action ב-C#?

Func מחזיר ערך ו-Action לא. ב-Func , ארגומנט הטיפוס האחרון (bool) הוא טיפוס ההחזרה והשאר הם פרמטרים. Action מקבל int ו-string ומחזיר void. לשניהם יש גרסאות עם 0 עד 16 פרמטרים.

Q: איך מעבירים פונקציה כפרמטר ב-C#?

הצהירו על הפרמטר כ-Func או כ-Action בצורה המתאימה וקראו לו בתוך המתודה: static decimal Apply(decimal price, Func rule) => rule(price);. מי שקורא מעביר lambda (Apply(80m, p => p * 0.9m)) או שם של מתודה (Apply(80m, HalfPrice)).

Q: איך משתמשים ב-Func עם קוד אסינכרוני?

השתמשו ב-Func לפונקציה אסינכרונית בלי תוצאה וב-Func > לפונקציה עם תוצאה, כדי שמי שקורא יוכל לבצע עליה await. הימנעו מהשמה של lambda אסינכרונית ל-Action: זה הופך אותה ל-async void, שאי אפשר להמתין לה ואי אפשר לתפוס את החריגות שלה אצל מי שקרא לה.

Q: האם ל-Func יכולים להיות פרמטרים out או ref?

לא. הפרמטרים הגנריים של Func ו-Action הם פרמטרי ערך רגילים, ולכן אין דרך לכתוב Func . לחתימה כמו TryParse, הצהירו על delegate מותאם: delegate bool TryParser (string text, out T value);.

Func ו-Action הם טיפוסי delegate גנריים ש-.NET מצהירה עליהם בשבילכם, כך שאפשר לשמור ולהעביר פונקציות בלי להצהיר קודם על טיפוס delegate. Func מחזיר ערך; Action לא מחזיר כלום.

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

פלט:

4
46.00
False
Hello!
Mia scored 87

הכלל שכדאי לזכור: ב-Func, ארגומנט הטיפוס האחרון הוא טיפוס ההחזרה. Func<int, int, bool> מקבל שני int ומחזיר bool. Func<int> לא מקבל כלום ומחזיר int. כל ארגומנטי הטיפוס של Action הם פרמטרים.

המשפחה

טיפוס	פרמטרים	מחזיר
`Action`	אין	`void`
`Action<T>`	`T`	`void`
`Action<T1, T2>` ... עד 16	`T1, T2, ...`	`void`
`Func<TResult>`	אין	`TResult`
`Func<T, TResult>`	`T`	`TResult`
`Func<T1, T2, TResult>` ... עד 16	`T1, T2, ...`	`TResult`
`Predicate<T>`	`T`	`bool`
`Comparison<T>`	`T, T`	`int` (שלילי, אפס, חיובי)
`Converter<TIn, TOut>`	`TIn`	`TOut`

Predicate, Comparison ו-Converter ותיקים יותר ומופיעים במתודות של List<T> ושל Array: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ משתמש ב-Func לאורך כל הדרך, ולכן list.Where(...) ו-list.FindAll(...) מקבלות lambdas באותה צורה אבל מטיפוסים שונים:

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

פלט:

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

העברת פונקציות למתודות

פרמטר מסוג Func או Action מאפשר למי שקורא לספק את החלק באלגוריתם שמשתנה. שתי צורות נפוצות הן "תריץ את זה ותמדוד" ו"תנסה את זה עד שזה עובד":

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

פלט:

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

Retry היא גנרית, ולכן ה-Func<int, T> שלה יכול להחזיר כל דבר; הקומפיילר הסיק ש-T הוא string מתוך ה-lambda. ה-lambda שמועברת ל-Twice משנה את המשתנה המקומי clicks, וזה עובד כי lambda לוכדת את המשתנה עצמו ולא עותק של הערך שלו.

Method groups: העברת מתודה לפי שם

לא צריך lambda כדי למלא Func או Action. השם של מתודה קיימת עם חתימה מתאימה (method group) מומר ישירות:

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

פלט:

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

Select(int.Parse) זהה ל-Select(s => int.Parse(s)), רק בלי שכבת קריאה אחת. הקומפיילר בוחר את ההעמסה שמתאימה לטיפוס היעד: ל-int.Parse יש כמה העמסות, ורק Parse(string) מתאימה ל-Func<string, int>. כשהקומפיילר לא מצליח להכריע (כמה העמסות מתאימות באותה מידה, או שאי אפשר להסיק את ארגומנטי הטיפוס של מתודה גנרית מתוך method group), הקריאה לא מתקמפלת, ו-lambda שכותבת את הקריאה במפורש פותרת את זה.

method group שמשמש כ-Func עדיין רץ מאוחר יותר, בכל פעם שמפעילים את ה-delegate, בדיוק כמו lambda. ההבדל הוא רק באופן הכתיבה.

החזרת פונקציות

מתודה יכולה לבנות פונקציה ולהחזיר אותה. ה-Func שמוחזר נושא איתו את הערכים שממנו הוא נבנה:

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

פלט:

140
180
162

Twice(staff) בונה פונקציה חדשה שמפעילה את הנחת העובדים פעמיים: 200, ואז 180, ואז 162.

מילון של פונקציות

שמירת פונקציות במילון הופכת switch ארוך לטבלת חיפוש. זו הצורה הרגילה למטפלי פקודות, למחשבונים ולפעולות תפריט, ואפשר להוסיף רשומות חדשות בזמן ריצה:

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

פלט:

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

הוספת אופרטור היא עוד רשומה אחת במילון, בלי שום שינוי בלולאה. ה-StringComparer.OrdinalIgnoreCase שמועבר למילון השני הופך את שמות הפקודות לבלתי תלויים באותיות גדולות וקטנות.

פונקציות אסינכרוניות: Func<Task>, לא Action

עם קוד async, טיפוס ה-delegate קובע אם מי שקורא יכול לחכות לעבודה:

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 אסינכרונית שמושמת ל-Action הופכת למתודת async void: שום דבר לא יכול לבצע עליה await, וחריגה שבתוכה לעולם לא מגיעה למי שקרא. היא נזרקת מחדש ב-thread pool (או ב-UI thread באפליקציית דסקטופ), ושם היא בדרך כלל מפילה את התהליך. כשכותבים מתודה שמקבלת עבודה אסינכרונית, קבלו Func<Task> (או Func<Task<T>>).

מתי להצהיר על delegate משלכם

Func ו-Action מכסים את רוב הצרכים. הצהירו על טיפוס delegate עם שם כאשר:

בחתימה יש פרמטרים ref, out או in. Func לא יכול לבטא אותם, ולכן פונקציה בסגנון TryParse צריכה delegate bool TryParser<T>(string text, out T value);.
השם מתעד תפקיד ב-API ציבורי. delegate bool Validator(string input) בחתימה של מתודה אומר יותר מ-Func<string, bool>, ושמות הפרמטרים שלו מופיעים ב-IntelliSense.
צריך פרמטר params, שגם הוא לא אפשרי ב-delegates גנריים.

אירועים הם המקום האחר שבו טיפוסי delegate מותאמים עדיין מופיעים, אם כי EventHandler<TEventArgs> המובנה מכסה את רובם. העמוד על delegates מכסה הצהרה ושילוב של טיפוסי delegate.

שאלות נפוצות

מה ההבדל בין Func ל-Action ב-C#?

Func מחזיר ערך ו-Action לא. ב-Func<int, string, bool>, ארגומנט הטיפוס האחרון (bool) הוא טיפוס ההחזרה והשאר הם פרמטרים. Action<int, string> מקבל int ו-string ומחזיר void. לשניהם יש גרסאות עם 0 עד 16 פרמטרים.

איך מעבירים פונקציה כפרמטר ב-C#?

הצהירו על הפרמטר כ-Func או כ-Action בצורה המתאימה וקראו לו בתוך המתודה: static decimal Apply(decimal price, Func<decimal, decimal> rule) => rule(price);. מי שקורא מעביר lambda (Apply(80m, p => p * 0.9m)) או שם של מתודה (Apply(80m, HalfPrice)).

מה זה Predicate<T> ב-C#?

טיפוס delegate שמקבל T ומחזיר bool, אותה צורה כמו Func<T, bool>. הוא קדם ל-Func ומשמש את List<T>.Find, FindAll, RemoveAll, Exists ו-Array.Find. שני הטיפוסים לא מומרים זה לזה, אבל lambda מומרת לכל אחד מהם.

איך משתמשים ב-Func עם קוד אסינכרוני?

השתמשו ב-Func<Task> לפונקציה אסינכרונית בלי תוצאה וב-Func<T, Task<TResult>> לפונקציה עם תוצאה, כדי שמי שקורא יוכל לבצע עליה await. הימנעו מהשמה של lambda אסינכרונית ל-Action: זה הופך אותה ל-async void, שאי אפשר להמתין לה ואי אפשר לתפוס את החריגות שלה אצל מי שקרא לה.

האם ל-Func יכולים להיות פרמטרים out או ref?

לא. הפרמטרים הגנריים של Func ו-Action הם פרמטרי ערך רגילים, ולכן אין דרך לכתוב Func<string, out int, bool>. לחתימה כמו TryParse, הצהירו על delegate מותאם: delegate bool TryParser<T>(string text, out T value);.

מושגים קשורים