break, continue ו-goto ב-C#: יציאה מלולאות ומלולאות מקוננות

break מסיים לולאה מוקדם. continue מדלג על שאר האיטרציה הנוכחית ועובר לבאה. שניהם חלים על הלולאה העוטפת הפנימית ביותר, והם עובדים באותה דרך ב-for, foreach, while ו-do while.

using System;

class Program
{
    static void Main()
    {
        int[] orderTotals = { 45, 0, 120, -5, 80, 999, 60 };

        foreach (int total in orderTotals)
        {
            if (total <= 0)
            {
                Console.WriteLine($"skip invalid total {total}");
                continue;
            }
            if (total == 999)
            {
                Console.WriteLine("test order found, stopping");
                break;
            }
            Console.WriteLine($"process order of {total}");
        }

        Console.WriteLine("after the loop");
    }
}

פלט:

process order of 45
skip invalid total 0
process order of 120
skip invalid total -5
process order of 80
test order found, stopping
after the loop

continue קפץ מעל שורת העיבוד עבור 0 ו--5. break עצר את הלולאה ב-999, כך שאף פעם לא הגענו ל-60, והביצוע המשיך בפקודה הראשונה שאחרי הלולאה.

break: לעצור כשהתשובה ידועה

השימוש הטיפוסי ב-break הוא חיפוש: ברגע שמצאתם את מה שחיפשתם, אין סיבה להסתכל על השאר.

using System;

class Program
{
    static void Main()
    {
        string[] emails = { "ana@shop.com", "invalid-address", "ben@shop.com" };
        int firstBad = -1;

        for (int i = 0; i < emails.Length; i++)
        {
            if (!emails[i].Contains("@"))
            {
                firstBad = i;
                break;
            }
        }

        Console.WriteLine(firstBad >= 0
            ? $"first invalid email at index {firstBad}"
            : "all emails look valid");
    }
}

פלט:

first invalid email at index 1

ביטוי הקידום (i++) לא רץ אחרי break, כך ש-i עדיין היה מחזיק את האינדקס התואם אילו הוצהר מחוץ ללולאה. לחיפושים פשוטים, קריאה לספרייה אומרת את אותו הדבר: Array.FindIndex(emails, e => !e.Contains("@")) מחזירה את האינדקס (או -1), ו-emails.Any(e => !e.Contains("@")) של LINQ עונה אם קיים ערך לא תקין.

continue: לדלג לאיטרציה הבאה

continue הוא guard clause ללולאות. במקום לעטוף את העבודה האמיתית ב-if, דחו בראש הלולאה את המקרים שאתם לא רוצים:

using System;

class Program
{
    static void Main()
    {
        string[] lines = { "name,price", "", "# discontinued", "pen,1.20", "mug,8.00" };

        foreach (string line in lines)
        {
            if (line.Length == 0) continue;           // blank line
            if (line.StartsWith("#")) continue;       // comment
            if (line == "name,price") continue;       // header row

            string[] parts = line.Split(',');
            Console.WriteLine($"{parts[0]} costs {parts[1]}");
        }
    }
}

פלט:

pen costs 1.20
mug costs 8.00

לאן continue ממשיך תלוי בלולאה. בלולאת for הוא מריץ את ביטוי הקידום ואז בודק את התנאי. בלולאת while הוא קופץ ישר לתנאי, וזה מוביל לבאג קלאסי:

int i = 0;
while (i < 10)
{
    if (i % 2 == 0)
        continue;        // i++ below is skipped: i stays 0 forever
    Console.WriteLine(i);
    i++;
}

עדכנו את המונה לפני כל continue, או השתמשו בלולאת for, שבה העדכון נמצא בכותרת ותמיד רץ.

break בתוך switch בתוך לולאה

ב-switch, break מסיים את קטע ה-case. כשה-switch הזה נמצא בלולאה, ה-break שייך ל-switch, לא ללולאה:

using System;

class Program
{
    static void Main()
    {
        string[] commands = { "add", "add", "quit", "add" };
        int count = 0;

        foreach (string cmd in commands)
        {
            switch (cmd)
            {
                case "add":
                    count++;
                    break;                 // leaves the switch
                case "quit":
                    Console.WriteLine("quit received");
                    goto done;             // leaves the loop too
            }
        }
        done:
        Console.WriteLine($"count = {count}");
    }
}

פלט:

quit received
count = 2

break רגיל ב-case של "quit" היה מסיים רק את ה-switch, הלולאה הייתה ממשיכה, ו-count היה 3. ה-goto קופץ ל-label שאחרי הלולאה. גם העברת הלולאה למתודה וכתיבת return ב-case הזה עובדות, ולא צריך label.

יציאה מלולאות מקוננות

ב-C# אין break עם label כמו break outer; של Java. כשחיפוש עובר דרך שתי לולאות מקוננות, break בלולאה הפנימית מסיים רק את הפנימית; הלולאה החיצונית עוברת לשורה הבאה שלה. יש שלושה פתרונות מקובלים.

1. דגל שהלולאה החיצונית בודקת:

using System;

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

        bool found = false;
        for (int row = 0; row < seats.GetLength(0) && !found; row++)
        {
            for (int col = 0; col < seats.GetLength(1); col++)
            {
                if (seats[row, col] == 0)
                {
                    Console.WriteLine($"first free seat: row {row}, seat {col}");
                    found = true;
                    break;
                }
            }
        }
    }
}

פלט:

first free seat: row 1, seat 2

2. goto ל-label שאחרי שתי הלולאות. זה המקום היחיד שבו הרבה מדריכי סגנון של C# מקבלים את goto, כי הוא מבטא בדיוק "צא משתי הלולאות":

for (int row = 0; row < rows; row++)
{
    for (int col = 0; col < cols; col++)
    {
        if (seats[row, col] == 0)
        {
            Console.WriteLine($"first free seat: row {row}, seat {col}");
            goto done;
        }
    }
}
done:
Console.WriteLine("search finished");

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

using System;

class Program
{
    static bool FindFreeSeat(int[,] seats, out int row, out int col)
    {
        for (row = 0; row < seats.GetLength(0); row++)
        {
            for (col = 0; col < seats.GetLength(1); col++)
            {
                if (seats[row, col] == 0)
                    return true;        // leaves both loops at once
            }
        }
        row = col = -1;
        return false;
    }

    static void Main()
    {
        int[,] seats = { { 1, 1, 1 }, { 1, 1, 0 }, { 0, 1, 1 } };

        int r, c;
        if (FindFreeSeat(seats, out r, out c))
            Console.WriteLine($"first free seat: row {r}, seat {c}");
        else
            Console.WriteLine("sold out");
    }
}

פלט:

first free seat: row 1, seat 2

C# 7.0 הציגה גם local functions, שמאפשרות לשים את מתודת העזר הזו בתוך המתודה הקוראת. התבנית של פרמטר out שבה השתמשנו כאן מוסברת בדף על ref ו-out.

goto ו-labels

label הוא מזהה ואחריו נקודתיים, ו-goto label; קופץ אליו. הכללים מחמירים מספיק כדי למנוע את השימוש הגרוע ביותר:

• ה-label חייב להיות באותה מתודה, באותו בלוק של ה-goto או בבלוק שעוטף אותו. אפשר לקפוץ החוצה מבלוקים אבל אף פעם לא פנימה: קפיצה ל-label בתוך גוף לולאה מבחוץ היא שגיאה CS0159 (no such label within the scope of the goto statement).
• אי אפשר לצאת מבלוק finally עם goto, break או continue.
• בתוך switch, goto case 3; ו-goto default; מעבירים את השליטה לקטע אחר. כך switch ב-C# מבטא fall-through, כי נפילה מרומזת ל-case הבא היא שגיאת קומפילציה.

goto יכול גם לבנות לולאות (קפיצה אחורה ל-label), אבל לולאת while אומרת את אותו הדבר בצורה שכל קורא מזהה. השאירו את goto ליציאה מלולאות מקוננות ולקטעי switch.

return, throw ולולאות

return יוצא מכל המתודה, ולכן גם מכל לולאה שבתוכה. throw עושה את אותו הדבר כשהוא זורק חריגה. בתוך בלוק try עם finally, כל אחד מ-break, continue, goto ו-return עדיין מריץ את בלוק ה-finally לפני שהשליטה עוברת הלאה, ובזכות זה בטוח לצאת מלולאה שמחזיקה קובץ פתוח בבלוק using.