Switch case ב-C#: פקודת switch עם case, break, default וכמה ערכים

פקודת switch משווה ערך אחד לרשימה של תוויות case קבועות ומריצה את הקטע שמתאים. ב-C#, כל קטע חייב להסתיים ב-break (או בפקודה אחרת שיוצאת ממנו), כך ש-case אחד לעולם לא יכול לרוץ בשקט לתוך הבא.

using System;

class Program
{
    static void Describe(int statusCode)
    {
        switch (statusCode)
        {
            case 200:
                Console.WriteLine($"{statusCode}: OK");
                break;
            case 301:
            case 302:
                Console.WriteLine($"{statusCode}: redirect");
                break;
            case 404:
                Console.WriteLine($"{statusCode}: not found");
                break;
            default:
                Console.WriteLine($"{statusCode}: unhandled status");
                break;
        }
    }

    static void Main()
    {
        int[] codes = { 200, 302, 404, 500 };
        foreach (int code in codes)
        {
            Describe(code);
        }
    }
}

פלט:

200: OK
302: redirect
404: not found
500: unhandled status

הערך שבסוגריים מחושב פעם אחת ומושווה לכל תווית. default רץ כששום דבר לא מתאים; הוא אופציונלי, והוא יכול להופיע בכל מקום ברשימה, אם כי בדרך כלל הוא בא אחרון. אם אין התאמה ואין default, כל ה-switch לא עושה כלום.

כל קטע צריך break

ב-C, C++, Java ו-JavaScript, שכחה של break גורמת לביצוע לגלוש ל-case הבא. C# הופכת את הטעות הזו לשגיאת קומפילציה:

switch (level)
{
    case 1:
        Console.WriteLine("read");
        // error CS0163: Control cannot fall through from one case label ('case 1:') to another
    case 2:
        Console.WriteLine("write");
        break;
}

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

• return יוצאת מכל המתודה, ולרוב זו הצורה המסודרת ביותר בתוך מתודת עזר קטנה.
• throw זורקת חריגה עבור ערך שלא אמור להופיע לעולם.
• continue קופצת לאיטרציה הבאה כשה-switch נמצא בתוך לולאה.
• goto case ו-goto default קופצות לקטע אחר בכוונה.

הקטע האחרון לא פטור. default: בתחתית בלי break נכשל עם CS8070, Control cannot fall out of switch from final case label ('default:').

כמה ערכים ב-case אחד

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

using System;

class Program
{
    static string Kind(char c)
    {
        switch (char.ToLowerInvariant(c))
        {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                return "vowel";
            case ' ':
            case '\t':
                return "space";
            default:
                return char.IsDigit(c) ? "digit" : "consonant or symbol";
        }
    }

    static void Main()
    {
        foreach (char c in "Ok 7")
        {
            Console.WriteLine($"'{c}' is a {Kind(c)}");
        }
    }
}

פלט:

'O' is a vowel
'k' is a consonant or symbol
' ' is a space
'7' is a digit

כל קטע כאן מסתיים ב-return, כך שאין צורך ב-break (break אחרי return היה קוד שאי אפשר להגיע אליו). שתי תוויות עם אותו ערך הן שגיאה, CS0152 The switch statement contains multiple cases with the label value '1', וכל תווית חייבת להיות קבוע בזמן קומפילציה: משתנה ב-case נכשל עם "a constant value is expected".

switch על מחרוזת

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

using System;

class Program
{
    static void Main()
    {
        string[] commands = { "start", "STOP", "  Status ", "restart", null };

        foreach (string raw in commands)
        {
            string command = raw == null ? null : raw.Trim().ToLowerInvariant();

            switch (command)
            {
                case "start":
                    Console.WriteLine("Starting the server");
                    break;
                case "stop":
                    Console.WriteLine("Stopping the server");
                    break;
                case "status":
                    Console.WriteLine("Server is running");
                    break;
                default:
                    Console.WriteLine($"Unknown command: {command ?? "(none)"}");
                    break;
            }
        }
    }
}

פלט:

Starting the server
Stopping the server
Server is running
Unknown command: restart
Unknown command: (none)

בלי ToLowerInvariant, "STOP" היה מגיע ל-default. מותר לבצע switch על ערך null: הוא לא מתאים לאף קבוע מחרוזת ונופל ל-default, כך שה-switch עצמו לעולם לא זורק חריגה.

switch על enum

בשביל זה switch נוצר: קבוצה סגורה של ערכים עם שמות.

using System;

enum OrderStatus { Pending, Paid, Shipped, Delivered, Cancelled }

class Program
{
    static string Next(OrderStatus status)
    {
        switch (status)
        {
            case OrderStatus.Pending:
                return "wait for payment";
            case OrderStatus.Paid:
                return "pack and ship";
            case OrderStatus.Shipped:
                return "track the parcel";
            case OrderStatus.Delivered:
            case OrderStatus.Cancelled:
                return "nothing, order is closed";
            default:
                throw new ArgumentOutOfRangeException(nameof(status));
        }
    }

    static void Main()
    {
        foreach (OrderStatus s in Enum.GetValues(typeof(OrderStatus)))
        {
            Console.WriteLine($"{s}: {Next(s)}");
        }
        try
        {
            Next((OrderStatus)42);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine($"{e.GetType().Name} for value 42");
        }
    }
}

פלט:

Pending: wait for payment
Paid: pack and ship
Shipped: track the parcel
Delivered: nothing, order is closed
Cancelled: nothing, order is closed
ArgumentOutOfRangeException for value 42

הקומפיילר לא בודק שפקודת switch מכסה כל איבר של ה-enum, ומשתנה enum יכול להחזיק כל מספר שלם של טיפוס הבסיס שלו ((OrderStatus)42 חוקי). ה-default שזורק חריגה הופך case שנשכח לכישלון מיידי וברור במקום פעולה שקטה שלא עושה כלום.

goto case ו-goto default

כש-case אחד באמת צריך להמשיך לתוך אחר, C# מחייבת אתכם לכתוב את הקפיצה:

using System;

class Program
{
    static void Grant(string role)
    {
        Console.WriteLine($"{role}:");
        switch (role)
        {
            case "admin":
                Console.WriteLine("  manage users");
                goto case "editor";
            case "editor":
                Console.WriteLine("  edit posts");
                goto default;
            default:
                Console.WriteLine("  read posts");
                break;
        }
    }

    static void Main()
    {
        Grant("admin");
        Grant("editor");
        Grant("guest");
    }
}

פלט:

admin:
  manage users
  edit posts
  read posts
editor:
  edit posts
  read posts
guest:
  read posts

goto case מקבלת קבוע שחייב להתאים לאחת התוויות באותו switch. זה נדיר בקוד אמיתי: התנהגות משותפת בדרך כלל ברורה יותר כמתודה שכמה מקרים קוראים לה. ובכל זאת, זו התשובה לשאלה "איך עושים fall through ב-C#".

משתנים בתוך מקרים

כל בלוק ה-switch הוא טווח (scope) אחד, כך ששני מקרים לא יכולים להצהיר על משתנה עם אותו שם:

switch (shape)
{
    case "square":
        int area = side * side;
        break;
    case "rectangle":
        int area = width * height;   // error CS0128: A local variable or function named 'area' is already defined in this scope
        break;
}

עטפו את הגוף של כל קטע בסוגריים מסולסלים כדי לתת לו טווח משלו: case "square": { int area = side * side; ... break; }.

break בתוך לולאה

break בתוך case יוצאת מה-switch, לא מהלולאה שסביבו. continue עושה את ההפך: switch הוא לא לולאה, ולכן continue עוברת לאיטרציה הבאה של הלולאה.

using System;

class Program
{
    static void Main()
    {
        string[] lines = { "10", "# comment", "25", "end", "99" };
        int total = 0;

        foreach (string line in lines)
        {
            switch (line)
            {
                case "end":
                    Console.WriteLine("end marker found");
                    break;              // leaves the switch only
                default:
                    if (line.StartsWith("#"))
                        continue;       // skips to the next line
                    total += int.Parse(line);
                    break;
            }
        }

        Console.WriteLine($"Total: {total}");
    }
}

פלט:

end marker found
Total: 134

הלולאה המשיכה אחרי "end" והוסיפה 99. כדי לעצור את הלולאה מתוך switch, הגדירו דגל ובדקו אותו אחרי ה-switch, או העבירו את הלולאה למתודה והשתמשו ב-return. העמוד על break ו-continue משווה בין האפשרויות.

תוויות case עם תבניות ו-when

מאז C# 7.0, תווית case יכולה להיות תבנית במקום קבוע: היא יכולה לבדוק את הטיפוס של הערך ולהוסיף תנאי when. הצורה הזו נפוצה בקוד C# מודרני:

static string Describe(object value)
{
    switch (value)
    {
        case null:
            return "nothing";
        case int n when n < 0:
            return $"negative int {n}";
        case int n:
            return $"int {n}";
        case string s when s.Length == 0:
            return "empty string";
        case string s:
            return $"string \"{s}\"";
        default:
            return $"other: {value.GetType().Name}";
    }
}

עם תבניות, הסדר חשוב: ה-case הראשון שמתאים מנצח, והקומפיילר מדווח על שגיאה כשאי אפשר להגיע ל-case כי case קודם כבר מכסה אותו (הצבת case int n: מעל case int n when n < 0: נכשלת). פסוקית ה-when עובדת גם על מקרים קבועים: case 0 when isAdmin:. C# 9 הוסיפה תבניות יחס ותבניות לוגיות, כך ש-case יכול להיכתב case >= 90: או case 'a' or 'e' or 'i':.

ב-C# 7 בלי תבניות, אותו מיון לפי טיפוס הוא שרשרת if עם תבנית הטיפוס is:

using System;

class Program
{
    static string Describe(object value)
    {
        if (value == null) return "nothing";
        if (value is int n) return n < 0 ? $"negative int {n}" : $"int {n}";
        if (value is string s) return s.Length == 0 ? "empty string" : $"string \"{s}\"";
        return $"other: {value.GetType().Name}";
    }

    static void Main()
    {
        object[] values = { -3, 12, "", "hi", 2.5m, null };
        foreach (object v in values)
        {
            Console.WriteLine(Describe(v));
        }
    }
}

פלט:

negative int -3
int 12
empty string
string "hi"
other: Decimal
nothing

כשכל ענף של switch רק מחשב ערך, ביטוי switch קצר עוד יותר: var grade = score switch { >= 90 => "A", >= 80 => "B", _ => "C" };. העמוד על ביטוי switch מכסה את התחביר, התבניות וכללי הכיסוי המלא שלו.

על מה אפשר לעשות switch