(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

switch (C#-Referenz)

Die switch-Anweisung ist eine Steuerungsanweisung, die einen auszuführenden switch-Abschnitt aus einer Liste von Kandidaten auswählt.

Eine switch-Anweisung enthält eine oder mehrere switch-Abschnitte. Jeder switch-Abschnitt enthält eine oder mehrere case-Bezeichnungen und eine Liste mit mindestens einer Anweisung. Das folgende Beispiel zeigt eine einfache switch-Anweisung, die über drei switch-Abschnitte verfügt. Jeder switch-Abschnitt enthält eine case-Bezeichnung, z. B. case 1, und zwei Anweisungen.


int caseSwitch = 1;
switch (caseSwitch)
{
    case 1:
        Console.WriteLine("Case 1");
        break;
    case 2:
        Console.WriteLine("Case 2");
        break;
    default:
        Console.WriteLine("Default case");
        break;
}


Jede case-Bezeichnung gibt einen konstanten Wert an. Mit der switch-Anweisung wird die Steuerung an den switch-Abschnitt übergeben, dessen case-Bezeichnung dem Wert im switch-Ausdruck (in diesem Beispiel caseSwitch) entspricht. Wenn keine case-Bezeichnung einen übereinstimmenden Wert enthält, wird die Steuerung an den default-Abschnitt übertragen, falls vorhanden. Wenn kein default-Abschnitt vorhanden ist, wird keine Aktion ausgeführt, und der switch-Anweisung wird die Steuerung entzogen. Im vorherigen Beispiel werden die Anweisungen im ersten switch-Abschnitt ausgeführt, da case 1 dem Wert von caseSwitch entspricht.

Eine switch-Anweisung kann eine beliebige Anzahl von switch-Abschnitten enthalten, und jeder Abschnitt kann eine oder mehrere case-Bezeichnungen haben (wie im Beispiel mit den case-Bezeichnungen für Zeichenfolgen weiter unten dargestellt). Allerdings können zwei case-Bezeichnungen nicht denselben konstanten Wert enthalten.

Die Ausführung der Anweisungsliste im ausgewählten switch-Abschnitt beginnt mit der ersten Anweisung und durchläuft in der Regel die Anweisungsliste, bis eine jump-Anweisung erreicht wird, z. B. break, goto case, return oder throw. An diesem Punkt wird die Steuerung der switch-Anweisung entzogen oder an eine andere case-Bezeichnung übertragen.

Im Gegensatz zu C++ lässt C# nicht zu, dass die Ausführung von einem switch-Abschnitt zum nächsten fortgesetzt wird. Im folgenden Code wird ein Fehler verursacht.

switch (caseSwitch)
{
    // The following switch section causes an error.
    case 1:
        Console.WriteLine("Case 1...");
        // Add a break or other jump statement here.
    case 2:
        Console.WriteLine("... and/or Case 2");
        break;
}

In C# muss das Ende von switch-Abschnitten, einschließlich dem letzten Abschnitt, nicht erreichbar sein. Das heißt, anders als in einigen anderen Sprachen, kann der Code nicht mit dem nächsten switch-Abschnitt fortfahren. Obwohl diese Bedingung normalerweise mithilfe einer break-Anweisung erfüllt wird, ist der folgende Fall auch zulässig, da hier das Ende der Anweisungsliste auf keinen Fall erreicht werden kann.

case 4:
    while (true)
        Console.WriteLine("Endless looping. . . .");

Das folgende Beispiel veranschaulicht die Anforderungen und Funktionen einer switch-Anweisung.


class Program
{
    static void Main(string[] args)
    {
        int switchExpression = 3;
        switch (switchExpression)
        {
            // A switch section can have more than one case label.
            case 0:
            case 1:
                Console.WriteLine("Case 0 or 1");
                // Most switch sections contain a jump statement, such as
                // a break, goto, or return. The end of the statement list
                // must be unreachable.
                break;
            case 2:
                Console.WriteLine("Case 2");
                break;
                // The following line causes a warning.
                Console.WriteLine("Unreachable code");
            // 7 - 4 in the following line evaluates to 3.
            case 7 - 4:
                Console.WriteLine("Case 3");
                break;
            // If the value of switchExpression is not 0, 1, 2, or 3, the
            // default case is executed.
            default:
                Console.WriteLine("Default case (optional)");
                // You cannot "fall through" any switch section, including
                // the last one.
                break;
        }
    }
}


Im abschließenden Beispiel steuern die Zeichenfolgenvariable, str und die case-Bezeichnungen für Zeichenfolgen den Ausführungsablauf.


class SwitchTest
{
    static void Main()
    {
        Console.WriteLine("Coffee sizes: 1=small 2=medium 3=large");
        Console.Write("Please enter your selection: ");
        string str = Console.ReadLine();
        int cost = 0;

        // Notice the goto statements in cases 2 and 3. The base cost of 25
        // cents is added to the additional cost for the medium and large sizes.
        switch (str)
        {
            case "1":
            case "small":
                cost += 25;
                break;
            case "2":
            case "medium":
                cost += 25;
                goto case "1";
            case "3":
            case "large":
                cost += 50;
                goto case "1";
            default:
                Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
                break;
        }
        if (cost != 0)
        {
            Console.WriteLine("Please insert {0} cents.", cost);
        }
        Console.WriteLine("Thank you for your business.");
    }
}
/*
    Sample Input: 2

    Sample Output:
    Coffee sizes: 1=small 2=medium 3=large
    Please enter your selection: 2
    Please insert 50 cents.
    Thank you for your business.
*/


Weitere Informationen finden Sie in der C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft