المعامل الثلاثي (?:) في C#: الصياغة والأنواع والتداخل و??

يختار المعامل الشرطي، الذي يُسمّى عادة المعامل الثلاثي (ternary)، بين قيمتين في تعبير واحد: condition ? valueIfTrue : valueIfFalse.

using System;

class Program
{
    static void Main()
    {
        int[] cartSizes = { 0, 1, 5 };

        foreach (int count in cartSizes)
        {
            string noun = count == 1 ? "item" : "items";
            decimal shipping = count >= 5 ? 0m : 4.99m;
            Console.WriteLine($"{count} {noun}, shipping {shipping}");
        }
    }
}

المخرجات:

0 items, shipping 4.99
1 item, shipping 4.99
5 items, shipping 0

يجب أن يكون الشرط bool. بعد تقييمه يُنفَّذ فرع واحد فقط من الفرعين؛ ولا يُقيَّم الآخر أبدًا. وهذا يجعل المعامل آمنًا للوصول المحروس مثل list.Count > 0 ? list[0] : "empty"، حيث كان تقييم list[0] على قائمة فارغة سيرمي استثناءً.

المعامل الثلاثي مقابل if/else

المعامل الثلاثي تعبير: ينتج قيمة تُسندها أو تمرّرها أو تعيدها. أما جملة if فتنفّذ عبارات. هاتان الدالتان تفعلان الشيء نفسه:

// with if/else
static string Status(int stock)
{
    if (stock > 0)
        return "in stock";
    else
        return "sold out";
}

// with the ternary
static string Status(int stock) => stock > 0 ? "in stock" : "sold out";

استخدم المعامل الثلاثي حين يكون الفرعان قيمتين قصيرتين من النوع نفسه. واستخدم if حين ينفّذ فرع عدة عبارات، أو له آثار جانبية، أو حين يكون الشرط طويلًا بحيث لا يتّسع السطر كله براحة.

لا يستطيع المعامل الثلاثي أن يحلّ محل if لا تؤدي إلا أفعالًا. هذا لا يُترجم:

stock > 0 ? Ship(order) : Refund(order);
// error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement

ولا يوجد معامل ثلاثي دون else: الجزءان ? و: إلزاميان دائمًا، لأن التعبير يجب أن يكون له قيمة في الحالتين.

يحتاج الفرعان إلى نوع مشترك

يستنتج المترجم نوع التعبير كله من فرعيه. يجب أن يتحوّل أحد الفرعين ضمنيًا إلى نوع الآخر. وحين لا يتحوّل أي منهما تحصل على CS0173:

var discount = isMember ? 10 : null;
// error CS0173: Type of conditional expression cannot be determined because
// there is no implicit conversion between 'int' and '<null>'

var label = inStock ? 1 : "none";
// error CS0173: ... between 'int' and 'string'

الإصلاح أن تحوّل أحد الفرعين إلى النوع الذي تريده، فيتحوّل الآخر إليه:

using System;

class Program
{
    static void Main()
    {
        bool isMember = false;
        int points = 7;

        int? discount = isMember ? (int?)10 : null;
        object reward = points > 5 ? (object)points : "none";
        double average = points > 0 ? points / 2.0 : 0;

        Console.WriteLine(discount.HasValue ? $"{discount}%" : "no discount");
        Console.WriteLine(reward);
        Console.WriteLine(average.ToString("F1"));
    }
}

المخرجات:

no discount
7
3.5

لا تحتاج points / 2.0 : 0 إلى تحويل: 0 من نوع int، الذي يتحوّل ضمنيًا إلى double، فيكون التعبير double.

أضافت C# 9 استهداف النوع: حين يُسند التعبير إلى نوع مصرّح به يستخدم المترجم ذلك النوع. تُترجم int? discount = isMember ? 10 : null; في C# 9 وما بعده. أما مع var فلا نوع هدف، فتظل var discount = isMember ? 10 : null; تفشل في كل إصدار.

الأولوية والأقواس

أولوية المعامل الشرطي منخفضة جدًا، أقل من + و== و&&. هذا مريح في a > b ? a : b، ومفاجئ داخل ضمّ النصوص:

Console.WriteLine("Status: " + isActive ? "on" : "off");
// error CS0029: Cannot implicitly convert type 'string' to 'bool'

يقرأ المترجم الشرط على أنه "Status: " + isActive، أي نص. الأقواس حول المعامل الثلاثي تصلح ذلك: "Status: " + (isActive ? "on" : "off").

لـ استيفاء النصوص فخّه الخاص. داخل { } تبدأ النقطتان محدّد تنسيق ({price:F2})، فيربك المعامل الثلاثي المكشوف المحلّل. ضعه بين أقواس:

using System;

class Program
{
    static void Main()
    {
        string[] users = { "ana", "ben" };
        int unread = 1;
        bool online = true;

        Console.WriteLine($"{users.Length} {(users.Length == 1 ? "user" : "users")} online");
        Console.WriteLine($"You have {unread} unread {(unread == 1 ? "message" : "messages")}");
        Console.WriteLine($"Status: {(online ? "online" : "away")}");
    }
}

المخرجات:

2 users online
You have 1 unread message
Status: online

المعاملات الثلاثية المتداخلة

يُجمَّع المعامل من النهاية، فيُقرأ a ? x : b ? y : z على أنه a ? x : (b ? y : z). سلسلة صغيرة بشرط واحد في كل سطر سهلة القراءة:

using System;

class Program
{
    static string Size(int bytes) =>
        bytes < 1024 ? $"{bytes} B" :
        bytes < 1024 * 1024 ? $"{bytes / 1024} KB" :
        $"{bytes / (1024 * 1024)} MB";

    static void Main()
    {
        Console.WriteLine(Size(512));
        Console.WriteLine(Size(20480));
        Console.WriteLine(Size(5242880));
    }
}

المخرجات:

512 B
20 KB
5 MB

بعد مستويين أو ثلاثة، أو حين تختبر الشروط أشياء مختلفة، انتقل إلى if/else if أو تعبير switch. والتداخل داخل الفرع الصحيح (a ? (b ? x : y) : z) هو الشكل الذي يصعب تتبّعه أولًا.

?? و?. تحلّان محل معاملات ثلاثية شائعة

كثير من المعاملات الثلاثية موجودة فقط لمعالجة null. في C# معاملات أقصر لها:

using System;

class Address { public string City; }
class Customer { public string Name; public Address Address; }

class Program
{
    static void Main()
    {
        Customer[] customers =
        {
            new Customer { Name = "Lena", Address = new Address { City = "Berlin" } },
            new Customer { Name = null, Address = null },
            null,
        };

        foreach (Customer c in customers)
        {
            string name = c?.Name ?? "guest";
            string city = c?.Address?.City ?? "unknown";
            Console.WriteLine($"{name} from {city}");
        }
    }
}

المخرجات:

Lena from Berlin
guest from unknown
guest from unknown

يُسمح أيضًا بتعبير throw في أي من فرعي المعامل الثلاثي: int age = input >= 0 ? input : throw new ArgumentOutOfRangeException(nameof(input));.

الشرطي المرجعي ref

منذ C# 7.2 يمكن للمعامل الثلاثي أن يختار بين متغيّرين بدل قيمتين، ويمكنك الإسناد عبر النتيجة:

// C# 7.2 and later
int wins = 0, losses = 0;
bool won = true;

ref int counter = ref (won ? ref wins : ref losses);
counter++;               // increments wins

يجب أن يكون الفرعان ref إلى متغيّرين من النوع نفسه. نادر في شيفرة التطبيقات؛ ويوجد أساسًا للشيفرة الحساسة للأداء التي تعمل مع بنى أو مصفوفات كبيرة دون نسخها.