AnweisungenStatements

Die Aktionen eines Programms werden mit Anweisungen ausgedrückt.The actions of a program are expressed using statements. C# unterstützt verschiedene Arten von Anweisungen, von denen ein Teil als eingebettete Anweisungen definiert ist.C# supports several different kinds of statements, a number of which are defined in terms of embedded statements.

Ein Block ermöglicht, mehrere Anweisungen in Kontexten zu schreiben, in denen eine einzelne Anweisung zulässig ist.A block permits multiple statements to be written in contexts where a single statement is allowed. Ein Block besteht aus einer Liste von Anweisungen, die zwischen den Trennzeichen { und } geschrieben sind.A block consists of a list of statements written between the delimiters { and }.

Deklarationsanweisungen werden verwendet, um lokale Variablen und Konstanten deklarieren.Declaration statements are used to declare local variables and constants.

Ausdrucksanweisungen werden zum Auswerten von Ausdrücken verwendet.Expression statements are used to evaluate expressions. Ausdrücke, die als Anweisungen verwendet werden können, enthalten Methodenaufrufe, Objektzuordnungen mit dem new-Operator, Zuweisungen mit = und den Verbundzuweisungsoperatoren, Inkrementier- und Dekrementiervorgänge unter Verwendung des ++- und ---Operators und await-Ausdrücke.Expressions that can be used as statements include method invocations, object allocations using the new operator, assignments using = and the compound assignment operators, increment and decrement operations using the ++ and -- operators and await expressions.

Auswahlanweisungen werden verwendet, um eine Anzahl von möglichen Anweisungen für die Ausführung anhand des Werts eines Ausdrucks auszuwählen.Selection statements are used to select one of a number of possible statements for execution based on the value of some expression. Zu dieser Gruppe gehören die if- und switch-Anweisungen.In this group are the if and switch statements.

Iterationsanweisungen werden verwendet, um eine eingebettete Anweisung wiederholt auszuführen.Iteration statements are used to execute repeatedly an embedded statement. Zu dieser Gruppe gehören die while-, do-, for- und foreach-Anweisungen.In this group are the while, do, for, and foreach statements.

Sprunganweisungen werden verwendet, um die Steuerung zu übertragen.Jump statements are used to transfer control. Zu dieser Gruppe gehören die break-, continue-, goto-, throw-, return- und yield-Anweisungen.In this group are the break, continue, goto, throw, return, and yield statements.

Mit der try... catch-Anweisung werden Ausnahmen abgefangen, die während der Ausführung eines Blocks auftreten, und mit der try... finally-Anweisung wird Finalisierungscode angegeben, der immer ausgeführt wird, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht.The try...catch statement is used to catch exceptions that occur during execution of a block, and the try...finally statement is used to specify finalization code that is always executed, whether an exception occurred or not.

Mit den Anweisungen checked und unchecked wird der Überlaufüberprüfungs-Kontext für arithmetische Operationen für Ganzzahltypen und Konvertierungen gesteuert.The checked and unchecked statements are used to control the overflow-checking context for integral-type arithmetic operations and conversions.

Die lock-Anweisung wird verwendet, um die Sperre für gegenseitigen Ausschluss für ein bestimmtes Objekt abzurufen, eine Anweisung auszuführen und die Sperre aufzuheben.The lock statement is used to obtain the mutual-exclusion lock for a given object, execute a statement, and then release the lock.

Die using-Anweisung wird verwendet, um eine Ressource abzurufen, eine Anweisung auszuführen und dann diese Ressource zu verwerfen.The using statement is used to obtain a resource, execute a statement, and then dispose of that resource.

Im Folgenden werden die Arten von Anweisungen aufgelistet, die verwendet werden können, und für jede ein Beispiel aufgeführt.The following lists the kinds of statements that can be used, and provides an example for each.

  • Deklaration lokaler Variablen:Local variable declaration:
static void Declarations(string[] args)
{
    int a;
    int b = 2, c = 3;
    a = 1;
    Console.WriteLine(a + b + c);
}
  • Deklaration lokaler Konstanten:Local constant declaration:
static void ConstantDeclarations(string[] args)
{
    const float pi = 3.1415927f;
    const int r = 25;
    Console.WriteLine(pi * r * r);
}
  • Ausdrucksanweisung:Expression statement:
static void Expressions(string[] args)
{
    int i;
    i = 123;                // Expression statement
    Console.WriteLine(i);   // Expression statement
    i++;                    // Expression statement
    Console.WriteLine(i);   // Expression statement
}
  • if-Anweisung:if statement:
static void IfStatement(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("No arguments");
    }
    else 
    {
        Console.WriteLine("One or more arguments");
    }
}
  • switch-Anweisung:switch statement:
static void SwitchStatement(string[] args)
{
    int n = args.Length;
    switch (n) 
    {
        case 0:
            Console.WriteLine("No arguments");
            break;
        case 1:
            Console.WriteLine("One argument");
            break;
        default:
            Console.WriteLine($"{n} arguments");
            break;
    }
}
  • while-Anweisung:while statement:
static void WhileStatement(string[] args)
{
    int i = 0;
    while (i < args.Length) 
    {
        Console.WriteLine(args[i]);
        i++;
    }
}
  • do-Anweisung:do statement:
static void DoStatement(string[] args)
{
    string s;
    do 
    {
        s = Console.ReadLine();
        Console.WriteLine(s);
    } while (!string.IsNullOrEmpty(s));
}

  • for-Anweisung:for statement:
static void ForStatement(string[] args)
{
    for (int i = 0; i < args.Length; i++) 
    {
        Console.WriteLine(args[i]);
    }
}
  • foreach-Anweisung:foreach statement:
static void ForEachStatement(string[] args)
{
    foreach (string s in args) 
    {
        Console.WriteLine(s);
    }
}
  • break-Anweisung:break statement:
static void BreakStatement(string[] args)
{
    while (true) 
    {
        string s = Console.ReadLine();
        if (string.IsNullOrEmpty(s)) 
            break;
        Console.WriteLine(s);
    }
}
  • continue-Anweisung:continue statement:
static void ContinueStatement(string[] args)
{
    for (int i = 0; i < args.Length; i++) 
    {
        if (args[i].StartsWith("/")) 
            continue;
        Console.WriteLine(args[i]);
    }
}
  • goto-Anweisung:goto statement:
static void GoToStatement(string[] args)
{
    int i = 0;
    goto check;
    loop:
    Console.WriteLine(args[i++]);
    check:
    if (i < args.Length) 
        goto loop;
}
  • return-Anweisung:return statement:
static int Add(int a, int b) 
{
    return a + b;
}
static void ReturnStatement(string[] args)
{
   Console.WriteLine(Add(1, 2));
   return;
}
  • yield-Anweisung:yield statement:
static IEnumerable<int> Range(int from, int to) 
{
    for (int i = from; i < to; i++) 
    {
        yield return i;
    }
    yield break;
}
static void YieldStatement(string[] args)
{
    foreach (int i in Range(-10,10)) 
    {
        Console.WriteLine(i);
    }
}
  • throw-Anweisungen und try-Anweisungen:throw statements and try statements:
static double Divide(double x, double y) 
{
    if (y == 0) 
        throw new DivideByZeroException();
    return x / y;
}
static void TryCatch(string[] args) 
{
    try 
    {
        if (args.Length != 2) 
        {
            throw new InvalidOperationException("Two numbers required");
        }
        double x = double.Parse(args[0]);
        double y = double.Parse(args[1]);
        Console.WriteLine(Divide(x, y));
    }
    catch (InvalidOperationException e) 
    {
        Console.WriteLine(e.Message);
    }
    finally 
    {
        Console.WriteLine("Good bye!");
    }
}
  • checked- und unchecked-Anweisungen:checked and unchecked statements:
static void CheckedUnchecked(string[] args) 
{
    int x = int.MaxValue;
    unchecked 
    {
        Console.WriteLine(x + 1);  // Overflow
    }
    checked 
    {
        Console.WriteLine(x + 1);  // Exception
    }     
}
  • lock-Anweisung:lock statement:
class Account
{
    decimal balance;
    private readonly object sync = new object();
    public void Withdraw(decimal amount) 
    {
        lock (sync) 
        {
            if (amount > balance) 
            {
                throw new Exception(
                    "Insufficient funds");
            }
            balance -= amount;
        }
    }
}
  • using-Anweisung:using statement:
static void UsingStatement(string[] args) 
{
    using (TextWriter w = File.CreateText("test.txt")) 
    {
        w.WriteLine("Line one");
        w.WriteLine("Line two");
        w.WriteLine("Line three");
    }
}