אופרטור טרנרי ב-C# (?:): תחביר, טיפוסים, קינון ו-??

האופרטור המותנה, שנקרא בדרך כלל האופרטור הטרנרי, בוחר בין שני ערכים בביטוי אחד: 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 הוסיפה טיפוס יעד (target typing): כשהביטוי מושם לטיפוס מוצהר, הקומפיילר משתמש בטיפוס הזה. 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 למשתנים מאותו טיפוס. זה נדיר בקוד אפליקציה; זה קיים בעיקר לקוד רגיש לביצועים שעובד עם structs גדולים או מערכים בלי להעתיק אותם.