Anweisungen (C#-Programmierhandbuch)

Aktualisiert: Juli 2008

Die Aktionen, die ein Programm ausführt, werden in Anweisungen ausgedrückt. Zu den üblichen Aktionen gehören das Deklarieren von Variablen, das Zuweisen von Werten, das Aufrufen von Methoden, das Durchlaufen von Auflistungen und die Verzweigung in unterschiedliche Codeblöcke in Abhängigkeit von einer gegebenen Bedingung. Die Reihenfolge, in der Anweisungen in einem Programm ausgeführt werden, wird als Ablaufsteuerung oder Ausführungsablauf bezeichnet. Die Ablaufsteuerung kann bei jeder Programmausführung unterschiedlich sein. Sie ist von den Reaktionen des Programms auf Eingaben zur Laufzeit abhängig.

Eine Anweisung kann aus einer einzigen Codezeile mit Semikolon am Ende oder einer Folge von einzeiligen Anweisungen in einem Block bestehen. Ein Anweisungsblock ist in geschweifte Klammern ({}) eingeschlossen und kann geschachtelte Blöcke enthalten. Im folgenden Code werden zwei Beispiele für einzeilige Anweisungen und ein mehrzeiliger Anweisungsblock dargestellt:

    static void Main() 
    {
        // Declaration statement.
        int counter;

        // Assignment statement.
        counter = 1;

        // Error! This is an expression, not an expression statement.
        // counter + 1; 

        // Declaration statements with initializers are functionally
        // equivalent to a declaration statement followed by assignment statement:         
        int[] radii = { 15, 32, 108, 74, 9 }; // Declare and initialize an array.
        const double pi = 3.14159; // Declare and initialize a constant.          

        // foreach statement block that contains multiple statements.
        foreach (int radius in radii)
        {
            // Declaration statement with initializer.
            double circumference = pi * (2 * radius);

            // Expression statement (method invocation). A single-line
            // statement can span multiple text lines because line breaks
            // are treated as white space, which is ignored by the compiler.
            System.Console.WriteLine("Radius of circle #{0} is {1}. Circumference = {2:N2}",
                                    counter, radius, circumference);

            // Expression statement (postfix increment).
            counter++;

        } // End of foreach statement block
    } // End of Main method body.
} // End of SimpleStatements class.
/*
   Output:
    Radius of circle #1 = 15. Circumference = 94.25
    Radius of circle #2 = 32. Circumference = 201.06
    Radius of circle #3 = 108. Circumference = 678.58
    Radius of circle #4 = 74. Circumference = 464.96
    Radius of circle #5 = 9. Circumference = 56.55
*/

Typen von Anweisungen

In der folgenden Tabelle sind die verschiedenen Typen von Anweisungen in C# und deren zugehörige Schlüsselwörter sowie Links zu Themen aufgeführt, die weitere Informationen enthalten:

// Variable declaration statements.
double area;
double radius = 2;

// Constant declaration statement.
const double pi = 3.14159;

// Expression statement (assignment).
area = 3.14 * (radius * radius);

// Error. Not a statement because no assignment:
//circ * 2;

// Expression statement (method invocation).
System.Console.WriteLine();

// Expression statement (new object creation).
System.Collections.Generic.List<string> strings =
    new System.Collections.Generic.List<string>();

void ProcessMessages()
{
    while (ProcessMessage())
        ; // Statement needed here.
}

void F()
{
    //...
    if (done) goto exit;
    //...
    exit:
    ; // Statement needed here.
}

Eingebettete Anweisungen

Auf einige Anweisungen, einschließlich do, while, for und foreach, folgt stets eine eingebettete Anweisung. Diese eingebettete Anweisung kann entweder aus einer einzelnen Anweisung oder aus mehreren, mit geschweiften Klammern ({}) in einen Anweisungsblock eingeschlossene Anweisungen bestehen. Wie im folgenden Beispiel gezeigt, können auch einzeilige eingebettete Anweisungen in geschweifte Klammern ({}) eingeschlossen werden:

// Recommended style. Embedded statement in a block.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
{
    System.Console.WriteLine(s);
}

// Not recommended.
foreach (string s in System.IO.Directory.GetDirectories(
                        System.Environment.CurrentDirectory))
    System.Console.WriteLine(s);

Bei einer nicht in geschweifte Klammern eingeschlossenen eingebetteten Anweisung darf es sich nicht um eine Deklarationsanweisung oder eine Anweisung mit Bezeichnung handeln. Dies wird im folgenden Beispiel dargestellt:

if(b == true)
    //Error CS1023:
    int radius = 5; 

Fügen Sie die eingebettete Anweisung in einen Block ein, um den Fehler zu beheben:

if(b == true)
{
    // OK:
    System.DateTime d = System.DateTime.Now;
    System.Console.WriteLine(d.ToLongDateString());
}

Geschachtelte Anweisungsblöcke

Wie im folgenden Code dargestellt, können Anweisungsblöcke geschachtelt werden:

foreach (string s in System.IO.Directory.GetDirectories(
    System.Environment.CurrentDirectory))
{
    if (s.StartsWith("CSharp"))
    {
        if (s.EndsWith("TempFolder"))
        {
            return s;
        }
    }

}
return "Not found.";

Nicht erreichbare Anweisungen

Wenn der Compiler feststellt, dass die Ablaufsteuerung eine bestimmte Anweisung unter keinen Umständen erreichen kann, löst er die Warnung "CS0162" aus. Dies wird im folgenden Beispiel dargestellt:

// An over-simplified example of unreachable code.
const int val = 5;
if (val < 4)
{
    System.Console.WriteLine("I'll never write anything."); //CS0162
}

Verwandte Abschnitte

• Anweisungsschlüsselwörter (C#-Referenz)

• Ausdrücke (C#-Programmierhandbuch)

• Operatoren (C#-Programmierhandbuch)

C#-Programmiersprachenspezifikation

Weitere Informationen finden Sie in den folgenden Abschnitten von C#-Programmiersprachenspezifikation:

• 1.5 Anweisungen

• 8 Anweisungen

Siehe auch

Konzepte

C#-Programmierhandbuch

Änderungsprotokoll