تعابير Lambda في C#: الصياغة وFunc وAction والإغلاقات و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، كائن يشير إلى دالة) من أي نوع مفوّض يتوقعه السياق: Func<decimal, decimal> هنا، وPredicate<T> لـ List.FindAll، وEventHandler لحدث. مفوّضات Func تعيد قيمة ومفوّضات 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;
}

lambda التعبير فيها تعبير واحد بعد =>، وقيمته هي النتيجة. أما lambda العبارات ففيها كتلة بين أقواس معقوصة، يمكن أن تحتوي على أي عبارات ويجب أن تعيد قيمة بـ return في كل مسار إن كان المفوّض يعيد قيمة (وإلا CS1643، Not all code paths return a value in lambda expression).

أضافت الإصدارات الأحدث أشكالًا أخرى، كلها اختيارية:

• C# 9: معاملات المُهمَل، فيمكن أن تكون عدة معاملات غير مستخدمة كلها _ ((_, _) => Save())، وتعابير lambda من نوع 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.

تمرير تعابير lambda إلى الدوال

أي دالة تأخذ معامل مفوّض تقبل تعبير 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 معنى "الإبقاء"؛ المستدعي يقرّر بتعبير lambda. وتعمل List.Sort بالطريقة نفسها: تعبير lambda مقارنة تعيد سالبًا أو صفرًا أو موجبًا، وتستدعيه Sort كلما احتاجت.

تعابير lambda في LINQ

LINQ هو المكان الذي تلتقي فيه معظم شيفرات C# بتعابير lambda. كل معامل استعلام يأخذ واحدًا: 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

لا تُنفَّذ تعابير lambda حيث تُكتب. يخزّنها LINQ ويستدعيها حين يُعدَّد الاستعلام بـ foreach أو ToList() أو Sum()، وهذا ما يُسمّى التنفيذ المؤجّل. تغطي صفحة LINQ المعاملات نفسها.

الإغلاقات: المتغيّرات الملتقطة

يمكن لتعبير 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.

فخ الالتقاط في الحلقات

التقاط متغيّر حلقة هو حيث تلدغ الإغلاقات. لحلقة 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

نُفّذت تعابير lambda الثلاثة في الحلقة الأولى بعد انتهاء الحلقة، حين كانت i تساوي 3. نسخ i إلى متغيّر مصرّح به داخل الجسم يمنح كل تعبير lambda متغيّره الخاص. أما foreach فتفعل الصواب وحدها: منذ C# 5 يكون متغيّر التكرار فيها متغيّرًا جديدًا في كل مرور. وقبل C# 5 كان فيها الخطأ نفسه، ولهذا ما زالت إجابات قديمة على الإنترنت توصي بالنسخ لـ foreach أيضًا.

الفخ نفسه ينطبق على كل ما يُنفَّذ لاحقًا: معالجات الأحداث، والمؤقتات، وTask.Run، واستعلامات LINQ المبنية في حلقة والمعدَّدة بعدها.

تعابير lambda والدوال المجهولة والدوال المحلية

حلّت تعابير lambda محل صياغة الدوال المجهولة في 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 أيضًا الدوال المحلية، التي لها اسم ويمكن أن تستدعي نفسها ولا تحجز مفوّضًا ما لم تحوّلها إلى واحد. استخدم تعبير lambda حين تمرّر سلوكًا إلى شيء ما (LINQ أو Sort أو حدث)؛ واستخدم دالة محلية أو دالة خاصة حين تستدعيها بنفسك.

يظهر تمييز آخر مع مزوّدي LINQ مثل Entity Framework: تعبير lambda المُسند إلى Expression<Func<T, bool>> لا يُترجم إلى شيفرة إطلاقًا بل إلى بنية بيانات تصف الشيفرة، يترجمها المزوّد إلى SQL. الصياغة متطابقة؛ ونوع معامل الدالة التي تستدعيها هو ما يحدد أيهما تحصل عليه.