Lambda ב-C#: תחביר, Func ו-Action, closures ו-LINQ

ביטוי lambda הוא פונקציה אנונימית קטנה שנכתבת בתוך הקוד עם האופרטור => ("הולך אל"). הפרמטרים נכתבים לפניו, והתוצאה אחריו:

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

class Program
{
    static void Main()
    {
        Func<decimal, decimal> addVat = price => price * 1.2m;
        Func<int, int, int> max = (a, b) => a > b ? a : b;
        Action<string> shout = text => Console.WriteLine(text.ToUpper() + "!");

        Console.WriteLine(addVat(50m));
        Console.WriteLine(max(7, 12));
        shout("order shipped");

        var prices = new List<decimal> { 12.5m, 80m, 5m, 150m };
        var expensive = prices.Where(p => p > 50m).Select(p => addVat(p));
        Console.WriteLine(string.Join(", ", expensive));
    }
}

פלט:

60.0
12
ORDER SHIPPED!
96.0, 180.0

ל-lambda אין טיפוס משלה. היא הופכת ל-delegate (אובייקט שמצביע על פונקציה) מכל טיפוס delegate שההקשר מצפה לו: כאן Func<decimal, decimal>, Predicate<T> עבור List.FindAll, EventHandler עבור אירוע. delegates מסוג Func מחזירים ערך ו-delegates מסוג Action לא; העמוד על Func ו-Action מפרט את כל המשפחה.

צורות התחביר

x => x * x                         // one parameter: parentheses optional
(x, y) => x + y                    // several parameters
() => DateTime.Now.Year            // no parameters
(int x, string s) => s.Length > x  // explicit parameter types
order =>                           // statement lambda: a block with return
{
    decimal subtotal = order.Qty * order.Price;
    return subtotal > 100m ? subtotal * 0.9m : subtotal;
}

ל-expression lambda יש ביטוי אחד אחרי =>, והערך שלו הוא התוצאה. ל-statement lambda יש בלוק בסוגריים מסולסלים, שיכול להכיל כל פקודה, וחייב לבצע return של ערך בכל מסלול אם ה-delegate מחזיר ערך (אחרת CS1643, Not all code paths return a value in lambda expression).

גרסאות חדשות יותר הוסיפו עוד צורות, כולן אופציונליות:

• C# 9: פרמטרי discard, כך שכמה פרמטרים שלא בשימוש יכולים כולם להיות _ ((_, _) => Save()), ו-lambdas מסוג static שאסור להן ללכוד משתנים.
• C# 10: "טיפוס טבעי", כך ש-var square = (int x) => x * x; מסיק Func<int, int>. לפני כן, var f = x => x * 2; נכשל; גם ב-C# 10 הוא עדיין נכשל בלי טיפוס לפרמטר, עם CS8917 The delegate type could not be inferred.
• C# 12: ערכי ברירת מחדל לפרמטרים, (int x, int y = 1) => x + y.

העברת lambdas למתודות

כל מתודה שמקבלת פרמטר delegate מקבלת lambda. כך מעבירים התנהגות ולא רק נתונים:

using System;
using System.Collections.Generic;

class Program
{
    static List<string> Filter(List<string> items, Func<string, bool> keep)
    {
        var result = new List<string>();
        foreach (string item in items)
        {
            if (keep(item)) result.Add(item);
        }
        return result;
    }

    static void Main()
    {
        var files = new List<string> { "report.pdf", "photo.jpg", "cv.txt", "scan.pdf" };

        var pdfs = Filter(files, f => f.EndsWith(".pdf"));
        var shortNames = Filter(files, f => f.Length <= 9);

        Console.WriteLine(string.Join(", ", pdfs));
        Console.WriteLine(string.Join(", ", shortNames));

        files.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine(string.Join(", ", files));
    }
}

פלט:

report.pdf, scan.pdf
photo.jpg, cv.txt, scan.pdf
cv.txt, scan.pdf, photo.jpg, report.pdf

Filter לא יודעת מה המשמעות של "keep"; מי שקורא מחליט עם lambda. List.Sort עובדת באותה צורה: ה-lambda היא השוואה שמחזירה ערך שלילי, אפס או חיובי, ו-Sort קוראת לה כמה פעמים שהיא צריכה.

Lambdas ב-LINQ

LINQ הוא המקום שבו רוב קוד C# פוגש lambdas. כל אופרטור שאילתה מקבל אחת: Where תנאי, Select הטלה, OrderBy מפתח, Sum ערך לסכום:

using System;
using System.Linq;

class Order
{
    public string Customer;
    public int Qty;
    public decimal Price;
}

class Program
{
    static void Main()
    {
        Order[] orders =
        {
            new Order { Customer = "Ana", Qty = 2, Price = 30m },
            new Order { Customer = "Ben", Qty = 1, Price = 250m },
            new Order { Customer = "Ana", Qty = 5, Price = 4m },
            new Order { Customer = "Cy",  Qty = 3, Price = 15m },
        };

        var bigOrders = orders
            .Where(o => o.Qty * o.Price >= 45m)
            .OrderByDescending(o => o.Qty * o.Price)
            .Select(o => $"{o.Customer}: {o.Qty * o.Price}");

        foreach (string line in bigOrders) Console.WriteLine(line);

        var perCustomer = orders
            .GroupBy(o => o.Customer)
            .Select(g => new { Name = g.Key, Total = g.Sum(o => o.Qty * o.Price) });

        foreach (var c in perCustomer) Console.WriteLine($"{c.Name} spent {c.Total}");
    }
}

פלט:

Ben: 250
Ana: 60
Cy: 45
Ana spent 80
Ben spent 250
Cy spent 45

ה-lambdas לא רצות במקום שבו הן נכתבו. LINQ שומר אותן וקורא להן כשעוברים על השאילתה עם foreach, ToList() או Sum(), מה שנקרא ביצוע נדחה (deferred execution). העמוד על LINQ מכסה את האופרטורים עצמם.

Closures: משתנים שנלכדו

lambda יכולה להשתמש במשתנים מקומיים ובפרמטרים של המתודה שבה היא נכתבה. היא לוכדת את המשתנה ולא את הערך הנוכחי שלו, והמשתנה ממשיך לחיות כל עוד ה-lambda חיה:

using System;

class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;      // count outlives MakeCounter
    }

    static void Main()
    {
        Func<int> next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());

        Func<int> other = MakeCounter();
        Console.WriteLine(other());

        decimal rate = 0.1m;
        Func<decimal, decimal> discount = price => price * rate;
        rate = 0.5m;                       // changed after the lambda was created
        Console.WriteLine(discount(100m)); // uses the current value
    }
}

פלט:

1
2
3
1
50.0

כל קריאה ל-MakeCounter יוצרת count חדש, ולכן שני המונים בלתי תלויים. ה-lambda של ההנחה קראה את rate כשהיא רצה, לא כשהיא נכתבה, ולכן היא החילה 50%. הקומפיילר מממש את זה כשהוא מעביר משתנים שנלכדו למחלקה נסתרת שהמתודה וה-lambda חולקות.

המלכודת של לכידה בלולאה

לכידה של משתנה לולאה היא המקום שבו closures נושכים. ללולאת for יש משתנה אחד לכל הלולאה, ולכן כל lambda שנוצרת בה חולקת את המשתנה הזה:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            actions.Add(() => Console.Write($"{i} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, shared i");

        actions.Clear();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;                       // a new variable each iteration
            actions.Add(() => Console.Write($"{copy} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, copied");

        actions.Clear();
        foreach (int n in new[] { 0, 1, 2 })
        {
            actions.Add(() => Console.Write($"{n} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- foreach");
    }
}

פלט:

3 3 3 <- for loop, shared i
0 1 2 <- for loop, copied
0 1 2 <- foreach

כל שלוש ה-lambdas בלולאה הראשונה רצו אחרי שהלולאה הסתיימה, כש-i היה 3. העתקה של i למשתנה שמוצהר בתוך הגוף נותנת לכל lambda משתנה משלה. foreach עושה את זה נכון בעצמה: מאז C# 5, משתנה האיטרציה שלה הוא משתנה חדש בכל סיבוב. לפני C# 5 היה בה אותו באג, ולכן תשובות ישנות ברשת עדיין ממליצות על העותק גם עבור foreach.

אותה מלכודת חלה על כל דבר שרץ מאוחר יותר: event handlers, טיימרים, Task.Run, ושאילתות LINQ שנבנות בלולאה ועוברים עליהן אחריה.

Lambdas, מתודות אנונימיות ופונקציות מקומיות

Lambdas החליפו את התחביר של מתודות אנונימיות מ-C# 2, שעדיין מתקמפל:

Func<int, bool> isEven = delegate (int n) { return n % 2 == 0; };   // C# 2 anonymous method
Func<int, bool> isEven2 = n => n % 2 == 0;                          // lambda

לפונקציית עזר שמשמשת רק בתוך מתודה אחת, C# 7.0 מציעה גם פונקציות מקומיות, שיש להן שם, שיכולות להיות רקורסיביות, ושלא מקצות delegate אלא אם ממירים אותן לכזה. השתמשו ב-lambda כשמעבירים התנהגות למשהו (LINQ, Sort, אירוע); השתמשו בפונקציה מקומית או במתודה פרטית כשאתם קוראים לה בעצמכם.

הבחנה נוספת מופיעה עם ספקי LINQ כמו Entity Framework: lambda שמושמת ל-Expression<Func<T, bool>> לא מתקמפלת לקוד בכלל, אלא למבנה נתונים שמתאר את הקוד, והספק מתרגם אותו ל-SQL. התחביר זהה; טיפוס הפרמטר של המתודה שקוראים לה קובע מה מקבלים.