المفوّضات Delegates في C#: التصريح والاستدعاء والتعدد ودوال الاستدعاء الراجع

المفوّض (delegate) نوع يمثّل توقيع دالة. يحمل متغيّر من نوع مفوّض مرجعًا إلى دالة بذلك التوقيع، واستدعاء المتغيّر يستدعي الدالة. هكذا تعامل C# الدوال كقيم: يمكنك تخزينها وتمريرها إلى دوال أخرى واستدعاؤها لاحقًا.

using System;

delegate decimal PriceRule(decimal price);

class Program
{
    static decimal HalfPrice(decimal p) => p / 2;
    static decimal MinusTen(decimal p) => p > 10m ? p - 10m : 0m;

    static void Main()
    {
        PriceRule rule = HalfPrice;
        Console.WriteLine(rule(80m));

        rule = MinusTen;
        Console.WriteLine(rule(80m));

        rule = p => p * 0.85m;
        Console.WriteLine(rule.Invoke(80m));
    }
}

المخرجات:

40
70
68.00

تصرّح delegate decimal PriceRule(decimal price); بنوع جديد، تمامًا كما تفعل class. أي دالة تأخذ decimal واحدًا وتعيد decimal تناسبه. أشار المتغيّر rule إلى ثلاث دوال مختلفة بالتتابع، وكل استدعاء نفّذ الدالة التي كان يحملها.

التصريح والإنشاء والاستدعاء

يبدو تصريح نوع المفوّض كتوقيع دالة تسبقه الكلمة delegate. ويوضع عادة على مستوى فضاء الأسماء، بجانب الأصناف، أو متداخلًا داخل صنف.

هناك أربع طرق لإنشاء مثيل مفوّض:

PriceRule a = HalfPrice;                             // method group (most common)
PriceRule b = new PriceRule(HalfPrice);              // explicit constructor, same thing
PriceRule c = p => p - 5m;                            // lambda expression
PriceRule d = delegate (decimal p) { return p; };    // anonymous method (C# 2 syntax)

وطريقتان لاستدعائه، متطابقتان: rule(80m) وrule.Invoke(80m). يفحص المترجم التوقيع وقت الإسناد، فتكون الدالة غير المطابقة خطأ ترجمة لا مفاجأة وقت التشغيل.

يمكن للمفوّض أن يشير إلى دالة مثيل أيضًا. عندها يتذكر الدالة والكائن الذي يستدعيها عليه:

using System;

delegate void Notify(string message);

class Mailbox
{
    private readonly string owner;
    public Mailbox(string owner) { this.owner = owner; }

    public void Receive(string message) => Console.WriteLine($"{owner} got: {message}");
}

class Program
{
    static void Main()
    {
        var ana = new Mailbox("Ana");
        Notify notify = ana.Receive;

        notify("Your order shipped");
        Console.WriteLine($"target: {notify.Target.GetType().Name}, method: {notify.Method.Name}");
    }
}

المخرجات:

Ana got: Your order shipped
target: Mailbox, method: Receive

Target هو الكائن الذي سيستدعي المفوّض الدالة عليه (null للدالة الساكنة)، وMethod تصف الدالة. وحمل الهدف يعني أيضًا أن المفوّض يبقي ذلك الكائن حيًا، وهذا مهم للأحداث.

المفوّضات كدوال استدعاء راجع

المهمة الرئيسية للمفوّض أن يتيح لدالة استدعاء شيفرة اختارها مستدعيها. تحدد الدالة متى يحدث شيء؛ ويحدد المستدعي ماذا:

using System;

delegate void ProgressHandler(int percent);

class Program
{
    static void ImportRows(string[] rows, ProgressHandler onProgress)
    {
        for (int i = 0; i < rows.Length; i++)
        {
            // ... import rows[i] ...
            int percent = (i + 1) * 100 / rows.Length;
            onProgress(percent);
        }
    }

    static void PrintBar(int percent)
    {
        Console.WriteLine($"[{new string('#', percent / 10),-10}] {percent}%");
    }

    static void Main()
    {
        string[] rows = { "a", "b", "c", "d" };

        ImportRows(rows, PrintBar);
        ImportRows(rows, p => { if (p == 100) Console.WriteLine("import finished"); });
    }
}

المخرجات:

[##        ] 25%
[#####     ] 50%
[#######   ] 75%
[##########] 100%
import finished

لا تعرف ImportRows شيئًا عن الكونسول أو الأشرطة. يمكن للدالة نفسها أن تقود شريط تقدم أو سطر سجل أو تحديث واجهة، بحسب ما يمرّره المستدعي. وتتبع List.Sort(Comparison<T>) وArray.Find(Predicate<T>) وTask.Run(Action) وكل معامل في LINQ هذا النمط.

المفوّضات المتعددة: += و-=

يمكن للمفوّض أن يحمل أكثر من دالة. تُلحق += دالة بقائمة استدعائه، وتحذفها -=، واستدعاء المفوّض يستدعي كل دالة بالترتيب:

using System;

delegate void OrderPlaced(string orderId);

class Program
{
    static void SendConfirmation(string id) => Console.WriteLine($"email sent for {id}");
    static void UpdateStock(string id) => Console.WriteLine($"stock updated for {id}");
    static void NotifyWarehouse(string id) => Console.WriteLine($"warehouse notified for {id}");

    static void Main()
    {
        OrderPlaced handlers = SendConfirmation;
        handlers += UpdateStock;
        handlers += NotifyWarehouse;

        handlers("A-1001");
        Console.WriteLine($"{handlers.GetInvocationList().Length} handlers");

        handlers -= UpdateStock;
        handlers("A-1002");
    }
}

المخرجات:

email sent for A-1001
stock updated for A-1001
warehouse notified for A-1001
3 handlers
email sent for A-1002
warehouse notified for A-1002

ثلاثة تفاصيل في المفوّضات المتعددة تهمّ عمليًا:

• القيم المعادة: إن كان نوع المفوّض يعيد قيمة، فاستدعاء مفوّض متعدد لا يعيد إلا نتيجة الدالة الأخيرة. لجمع كل النتائج مرّ على GetInvocationList() واستدعِ كلًّا منها بنفسك.
• الاستثناءات: إن رمت دالة واحدة استثناءً فلا تُنفَّذ الدوال الباقية ويصل الاستثناء إلى المستدعي.
• عدم القابلية للتغيير: المفوّضات غير قابلة للتغيير. تنشئ += مفوّضًا جديدًا بقائمة أطول وتسنده إلى المتغيّر، ولهذا لا يؤثر الحذف بـ -= على نسخة في الأصل.

حذف تعبير lambda بـ -= لا يعمل إلا إن مرّرت مثيل المفوّض نفسه. كتابة تعبير lambda نفسه مرتين تنشئ مفوّضين مختلفين، فلا تحذف handlers -= id => Log(id); شيئًا. خزّن تعبير lambda في متغيّر حين تنوي إلغاء اشتراكه.

المفوّضات null و?.Invoke

متغيّر المفوّض الذي لم يُسند إليه شيء يكون null، وحذف الدالة الأخيرة بـ -= يتركه null أيضًا. استدعاء null يرمي NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        Action<string> onSaved = null;

        onSaved?.Invoke("draft.txt");          // nothing happens
        Console.WriteLine("no handler, no crash");

        onSaved += name => Console.WriteLine($"saved {name}");
        onSaved?.Invoke("draft.txt");

        try
        {
            Action<string> missing = null;
            missing("x");
        }
        catch (NullReferenceException e)
        {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

المخرجات:

no handler, no crash
saved draft.txt
NullReferenceException

?.Invoke هي الطريقة القياسية لاستدعاء دالة استدعاء راجع اختيارية. لا يمكن وضع المعامل ?. مباشرة قبل الأقواس (onSaved?("x") ليست صياغة صحيحة)، فيستدعي النمط دالة Invoke في المفوّض باسمها، وهي تفعل ما يفعله الاستدعاء المختصر.

المفوّضات وFunc وAction والأحداث

التصريح بنوع مفوّض لكل توقيع سيكون مملًا، لذا توفّر .NET أنواعًا عامة:

PriceRule من المثال الأول بشكل Func<decimal, decimal> نفسه، ومع ذلك هما نوعان مختلفان ولا يتحوّل أحدهما إلى الآخر. وحتى نوعان مدمجان بتوقيعين متطابقين لا يتحوّلان:

Func<int, bool> isPositive = x => x > 0;
Predicate<int> p = isPositive;
// error CS0029: Cannot implicitly convert type 'System.Func<int, bool>' to 'System.Predicate<int>'

Predicate<int> ok = new Predicate<int>(isPositive);   // wrap it explicitly
Predicate<int> ok2 = x => isPositive(x);              // or with a lambda

يتحوّل تعبير lambda إلى أي نوع مفوّض متوافق، لذا تأخذ واجهات API عادة تعابير lambda ولا يُطرح السؤال أبدًا. تغطي صفحة Func وAction العائلة العامة ومتى يظل التصريح المخصص مجديًا.

الأحداث مبنية مباشرة على المفوّضات. حقل event مفوّض متعدد لا يستطيع الشيفرة الخارجية سوى += و-= عليه، ولا تستطيع أبدًا استدعاءه أو استبداله. قائمة المشتركين في مثال التعدد أعلاه هي بالضبط ما يديره الحدث عنك، مع تلك الحماية الإضافية. الأحداث مشروحة في صفحتها الخاصة.