Anweisungen (C#-Programmierhandbuch)

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  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  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:

Kategorie	C#-Schlüsselwörter/Hinweise
Deklarationsanweisungen	Mit einer Deklarationsanweisung wird eine neue Variable oder Konstante eingeführt. In einer Variablendeklaration kann der Variable optional ein Wert zugewiesen werden. In der Deklaration einer Konstanten ist die Zuweisung erforderlich. // Variable declaration statements. double area; double radius = 2; // Constant declaration statement. const double pi = 3.14159;
Ausdrucksanweisungen	Ausdrucksanweisungen, mit denen ein Wert berechnet wird, müssen den Wert in einer Variablen speichern. // Expression statement (assignment). area = 3.14 * (radius * radius); // Error. Not 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>();
Auswahlanweisungen	Mithilfe von Auswahlanweisungen kann in Abhängigkeit von einer oder mehreren angegebenen Bedingungen in verschiedene Abschnitte im Code verzweigt werden. Weitere Informationen finden Sie unter den folgenden Themen: "if", "else", "switch", "case"
Iterationsanweisungen	Mit Iterationsanweisungen können Auflistungen wie Arrays durchlaufen oder dieselben Sätze von Anweisungen wiederholt ausgeführt werden, bis eine angegebene Bedingung erfüllt ist. Weitere Informationen finden Sie unter den folgenden Themen: "do", "for", "foreach", "in", "while"
Sprunganweisungen	Sprunganweisungen übergeben die Steuerung an einen anderen Abschnitt im Code. Weitere Informationen finden Sie unter den folgenden Themen: break, continue, default, goto, return, yield
Ausnahmebehandlungsanweisungen	Ausnahmebehandlungsanweisungen ermöglichen die normale Wiederherstellung bei zur Laufzeit auftretenden Ausnahmebedingungen. Weitere Informationen finden Sie unter den folgenden Themen: "throw", "try-catch", "try-finally", "try-catch-finally"
checked und unchecked	Mit der checked-Anweisung und der unchecked-Anweisung kann angegeben werden, ob numerische Operationen einen Überlauf verursachen dürfen, wenn das Ergebnis in einer Variablen gespeichert wird, deren Wertebereich zu klein für den Ergebniswert ist. Weitere Informationen finden Sie unter checked und unchecked.
Die fixed-Anweisung	Mit der fixed-Anweisung wird verhindert, dass der Garbage Collector eine bewegliche Variable verschiebt. Weitere Informationen finden Sie unter fixed.
Die lock-Anweisung	Mit der lock-Anweisung kann der Zugriff auf Codeblöcke auf jeweils einen Thread eingeschränkt werden. Weitere Informationen finden Sie unter lock.
Anweisungen mit Bezeichnung	Sie können eine Anweisung mit einer Bezeichnung versehen und mit dem goto-Schlüsselwort zu dieser Anweisung mit Bezeichnung springen. (Siehe das Beispiel in der folgenden Zeile.)
Die leere Anweisung	Die leere Anweisung besteht aus einem einzelnen Semikolon. Sie führt keine Aktionen aus und kann an Stellen verwendet werden, an denen eine Anweisung erforderlich ist, jedoch keine Aktion ausgeführt werden soll. In den folgenden Beispielen werden zwei Verwendungen einer leeren Anweisung veranschaulicht: 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  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(pointB == 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 der C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auch

Konzepte

C#-Programmierhandbuch