ביטוי switch ב-C# (switch expression): תחביר, תבניות, discard ו-when

ביטוי switch ממפה ערך קלט לתוצאה. הוא נוסף ב-C# 8 ומחליף את הדפוס הנפוץ של פקודת switch שבה כל case רק מחזיר או משים משהו:

// C# 8 and later
string StatusText(int code) => code switch
{
    200 => "OK",
    301 or 302 => "Redirect",   // 'or' needs C# 9
    404 => "Not Found",
    >= 500 => "Server Error",   // relational patterns need C# 9
    _ => "Unknown"
};

קראו אותו מלמעלה למטה: הערך שלפני switch נבדק מול כל זרוע לפי הסדר, והזרוע הראשונה שהתבנית שלה מתאימה מספקת את התוצאה. אין case, אין break ואין מילת מפתח default; _ (תבנית ה-discard) מתאימה לכל דבר ומשמשת כברירת מחדל.

ב-C# 7, אותו מיפוי הוא פקודת switch במתודה קטנה, עם return בכל case:

using System;

class Program
{
    static string StatusText(int code)
    {
        switch (code)
        {
            case 200: return "OK";
            case 301:
            case 302: return "Redirect";
            case 404: return "Not Found";
            default: return code >= 500 ? "Server Error" : "Unknown";
        }
    }

    static void Main()
    {
        foreach (int code in new[] { 200, 302, 404, 503, 418 })
        {
            Console.WriteLine($"{code} {StatusText(code)}");
        }
    }
}

פלט:

200 OK
302 Redirect
404 Not Found
503 Server Error
418 Unknown

צורת הביטוי קצרה יותר בעיקר כי כל זרוע היא שורה אחת וגוף המתודה נעלם. היא גם ביטוי, כך שהיא יכולה לשבת בכל מקום שבו יכול לשבת ערך: ארגומנט, חור אינטרפולציה, return, מאתחל שדה.

כללי התחביר

var result = input switch
{
    pattern1 => value1,
    pattern2 when condition => value2,
    _ => fallback
};

• הקלט בא ראשון, ואחריו switch. זה ההפך מצורת הפקודה.
• כל זרוע היא pattern => expression. הצד הימני חייב להיות ביטוי יחיד; ללוגיקה נוספת, קראו למתודה.
• הזרועות מופרדות בפסיקים. מותר פסיק אחרי הזרוע האחרונה.
• כל המבנה הוא ביטוי, כך שפקודה שמשתמשת בו מסתיימת ב-; אחרי הסוגר המסולסל הסוגר.
• כל הזרועות חייבות לייצר ערכים מטיפוס משותף. var x = n switch { 0 => "zero", _ => 0 }; לא מתקמפל (CS8506, אין טיפוס מתאים ביותר). מאז C# 9 טיפוס יעד מוצהר פותר את זה: object x = n switch { 0 => "zero", _ => 0 }; מתקמפל.
• כל זרוע חייבת לייצר ערך, כך שזרוע לא יכולה לקרוא למתודת void כמו Console.WriteLine, וביטוי switch לא יכול לעמוד לבדו כפקודה (CS0201). לפעולות, השתמשו בפקודת switch.
• זרוע יכולה לזרוק חריגה במקום לייצר ערך: _ => throw new ArgumentOutOfRangeException(nameof(input)).
• הקומפיילר דוחה זרוע שלעולם לא ניתן להגיע אליה כי זרוע קודמת כבר מכסה אותה, עם שגיאה CS8510, The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match. שימו זרועות ספציפיות לפני כלליות.

תבניות יחס ותבניות לוגיות (C# 9)

C# 9 הוסיפה את <, <=, >, >= כתבניות, ואת המחברים and, or ו-not. בעזרתם טבלאות טווחים נקראות כמו מפרט:

// C# 9 and later
string Grade(int score) => score switch
{
    < 0 or > 100 => throw new ArgumentOutOfRangeException(nameof(score)),
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

string AgeGroup(int age) => age switch
{
    < 13 => "child",
    >= 13 and <= 19 => "teen",
    _ => "adult"
};

bool IsLetter(char c) => c is >= 'a' and <= 'z' or >= 'A' and <= 'Z';

מכיוון שהזרועות נבדקות לפי הסדר, >= 80 רואה רק ציונים מתחת ל-90. תבניות יחס מקבלות רק קבועים בצד הימני; כדי להשוות למשתנה, השתמשו בתנאי when. המקבילה ב-C# 7 לטבלת טווחים היא שרשרת if:

using System;

class Program
{
    static string Grade(int score)
    {
        if (score < 0 || score > 100)
            throw new ArgumentOutOfRangeException(nameof(score));
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        if (score >= 60) return "D";
        return "F";
    }

    static void Main()
    {
        foreach (int s in new[] { 95, 83, 71, 64, 12 })
        {
            Console.WriteLine($"{s} -> {Grade(s)}");
        }
    }
}

פלט:

95 -> A
83 -> B
71 -> C
64 -> D
12 -> F

not משמש לרוב בתור not null: x is not null, או זרוע not null => x.Name.

תבניות מאפיינים

תבנית מאפיינים מתאימה לפי האיברים של אובייקט: { Property: pattern, ... }. בשילוב עם ביטוי switch, היא מבטאת כללים עסקיים בלי שרשרת של תנאי &&:

// C# 8 and later
decimal ShippingCost(Order order) => order switch
{
    { Total: >= 100m } => 0m,                       // relational inside: C# 9
    { Country: "US", Express: true } => 15m,
    { Country: "US" } => 5m,
    { Express: true } => 30m,
    null => throw new ArgumentNullException(nameof(order)),
    _ => 12m
};

כל מאפיין שמופיע חייב להתאים כדי שהזרוע תתאים. תבנית מאפיינים ריקה { } מתאימה לכל ערך שאינו null. C# 10 הוסיפה תבניות מאפיינים מורחבות לאיברים מקוננים: { Customer.Address.Country: "US" } במקום { Customer: { Address: { Country: "US" } } }.

תבניות tuple

switch על tuple מתאים כמה ערכים בבת אחת, וזו הדרך הנקייה לבטא טבלת החלטות:

// C# 9 and later (the 'or' pattern)
string Winner(string a, string b) => (a, b) switch
{
    ("rock", "scissors") or ("scissors", "paper") or ("paper", "rock") => "player 1",
    var (x, y) when x == y => "draw",
    _ => "player 2"
};

var (x, y) מפרק את ה-tuple לשני משתנים שתנאי ה-when יכול להשוות. ב-C# 7 התחליף המקובל הוא לשלב את הערכים למפתח אחד, או להשתמש במילון של תוצאות:

using System;
using System.Collections.Generic;

class Program
{
    static readonly HashSet<string> Beats = new HashSet<string>
    {
        "rock/scissors", "scissors/paper", "paper/rock"
    };

    static string Winner(string a, string b)
    {
        if (a == b) return "draw";
        return Beats.Contains(a + "/" + b) ? "player 1" : "player 2";
    }

    static void Main()
    {
        Console.WriteLine(Winner("rock", "scissors"));
        Console.WriteLine(Winner("paper", "scissors"));
        Console.WriteLine(Winner("paper", "paper"));
    }
}

פלט:

player 1
player 2
draw

תבניות טיפוס ו-when

זרוע יכולה לבדוק את טיפוס זמן הריצה ולקשור משתנה, ופסוקית when מוסיפה כל תנאי שתחביר התבניות לא יכול לבטא:

// C# 8 and later
double Area(Shape shape) => shape switch
{
    Circle c => Math.PI * c.Radius * c.Radius,
    Rectangle r when r.Width == r.Height => r.Width * r.Width,
    Rectangle r => r.Width * r.Height,
    null => throw new ArgumentNullException(nameof(shape)),
    _ => throw new NotSupportedException(shape.GetType().Name)
};

גרסת C# 7 משתמשת בתבנית הטיפוס is בשרשרת if, שקושרת את המשתנה באותו אופן:

using System;

class Shape { }
class Circle : Shape { public double Radius; }
class Rectangle : Shape { public double Width, Height; }

class Program
{
    static double Area(Shape shape)
    {
        if (shape is Circle c) return Math.PI * c.Radius * c.Radius;
        if (shape is Rectangle r) return r.Width * r.Height;
        throw new ArgumentException("unknown shape");
    }

    static void Main()
    {
        Shape[] shapes = { new Circle { Radius = 2 }, new Rectangle { Width = 3, Height = 4.5 } };
        foreach (Shape s in shapes)
        {
            Console.WriteLine($"{s.GetType().Name}: {Area(s):F2}");
        }
    }
}

פלט:

Circle: 12.57
Rectangle: 13.50

כיסוי מלא ו-SwitchExpressionException

ביטוי switch חייב לייצר ערך לכל קלט. כשהקומפיילר רואה קלטים שאף זרוע לא מתאימה להם, הוא מזהיר:

warning CS8509: The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '0' is not covered.

זו אזהרה, לא שגיאה, כך שהקוד עדיין נבנה. אם ערך שלא הותאם מגיע בזמן ריצה, הביטוי זורק System.Runtime.CompilerServices.SwitchExpressionException, שההודעה שלו מסתיימת בערך שלא הותאם (Unmatched value was 3.).

ל-enums יש מקרה מיוחד. גם כשלכל איבר עם שם יש זרוע, משתנה enum יכול להחזיק כל מספר שלם ((Size)3), ולכן הקומפיילר מדווח על CS8524 עבור "ערך enum ללא שם":

// C# 8 and later
enum Size { Small, Medium, Large }

string Code(Size s) => s switch
{
    Size.Small => "S",
    Size.Medium => "M",
    Size.Large => "L",
    // warning CS8524 without the next arm
    _ => throw new ArgumentOutOfRangeException(nameof(s))
};

הוסיפו זרוע _ מפורשת שזורקת חריגה מועילה. זה מתעד את ההנחה, משתיק את האזהרה, ונותן שגיאה ברורה יותר מ-SwitchExpressionException אם ערך שגוי יופיע אי פעם.

מילון כחלופה

כשהזרועות הן זוגות טהורים של קבוע וערך, והטבלה עשויה לגדול או להגיע מקונפיגורציה, Dictionary עושה את אותה עבודה בכל גרסה של C# ואפשר לבנות אותו בזמן ריצה:

using System;
using System.Collections.Generic;

class Program
{
    static readonly Dictionary<string, decimal> VatRates = new Dictionary<string, decimal>
    {
        ["DE"] = 0.19m,
        ["FR"] = 0.20m,
        ["IE"] = 0.23m,
    };

    static decimal Vat(string country, decimal net)
    {
        decimal rate;
        if (!VatRates.TryGetValue(country, out rate))
            rate = 0m;
        return net * rate;
    }

    static void Main()
    {
        Console.WriteLine(Vat("DE", 100m));
        Console.WriteLine(Vat("IE", 50m));
        Console.WriteLine(Vat("US", 80m));
    }
}

פלט:

19.00
11.50
0

מדינה לא מוכרת מקבלת שיעור של 0m. למכפלה של decimal יש מספר ספרות אחרי הנקודה ששווה לסכום של שני האופרנדים, ולכן 100m * 0.19m מדפיס 19.00 והשיעור האפס מדפיס 0.

ביטוי switch מול פקודת switch

שתי הצורות מקבלות את אותן תבניות (טיפוסים, קבועים, מאפיינים, tuples, יחס), כך שמי שלומד אחת לומד גם את השנייה. הבחירה היא עניין של צורה: ערך עובר דרך הביטוי, רצף של פעולות עובר דרך הפקודה.