AnweisungenStatements

C# bietet eine Vielzahl von Anweisungen.C# provides a variety of statements. Die meisten dieser Anweisungen werden Entwicklern vertraut sein, die in C und C++ programmiert haben.Most of these statements will be familiar to developers who have programmed in C and C++.

statement
    : labeled_statement
    | declaration_statement
    | embedded_statement
    ;

embedded_statement
    : block
    | empty_statement
    | expression_statement
    | selection_statement
    | iteration_statement
    | jump_statement
    | try_statement
    | checked_statement
    | unchecked_statement
    | lock_statement
    | using_statement
    | yield_statement
    | embedded_statement_unsafe
    ;

Die Embedded_statement nichtterminal wird verwendet, Anweisungen, die in anderen Anweisungen angezeigt werden.The embedded_statement nonterminal is used for statements that appear within other statements. Die Verwendung von Embedded_statement statt Anweisung schließt die Verwendung von deklarationsanweisungen und Anweisungen mit Bezeichnung in diesen Kontexten.The use of embedded_statement rather than statement excludes the use of declaration statements and labeled statements in these contexts. Im BeispielThe example

void F(bool b) {
    if (b)
        int i = 44;
}

führt zu einem Kompilierzeitfehler, da ein if -Anweisung erfordert eine Embedded_statement anstelle eines Anweisung für die If Branch.results in a compile-time error because an if statement requires an embedded_statement rather than a statement for its if branch. Wenn dieser Code wurden zulässig, klicken Sie dann die Variable i deklariert werden würde, aber nie verwendet werden kann.If this code were permitted, then the variable i would be declared, but it could never be used. Beachten Sie jedoch, indem Sie platzieren ider Deklaration in einem Block, der im Beispiel ist gültig.Note, however, that by placing i's declaration in a block, the example is valid.

Endpunkte und ErreichbarkeitEnd points and reachability

Jede Anweisung verfügt über eine Endpunkt.Every statement has an end point. Intuitiv ausgedrückt ist der Endpunkt einer Anweisung den Speicherort an, der die Anweisung unmittelbar folgt.In intuitive terms, the end point of a statement is the location that immediately follows the statement. Die Ausführungsregeln für zusammengesetzte Statements (Anweisungen, die eingebettete Anweisungen enthalten) Geben Sie die Aktion, die ausgeführt wird, wenn die Steuerung der Endpunkt, der eine eingebettete Anweisung erreicht.The execution rules for composite statements (statements that contain embedded statements) specify the action that is taken when control reaches the end point of an embedded statement. Bei der Kontrolle über den Endpunkt einer Anweisung in einem Block erreicht, wird z. B. die Steuerung an die nächste Anweisung im-Block übergeben.For example, when control reaches the end point of a statement in a block, control is transferred to the next statement in the block.

Wenn eine Anweisung möglicherweise durch die Ausführung erreicht werden kann, die Anweisung gilt erreichbar.If a statement can possibly be reached by execution, the statement is said to be reachable. Im Gegensatz dazu ist es nicht möglich, dass eine Anweisung ausgeführt wird, die Anweisung gilt nicht erreichbar.Conversely, if there is no possibility that a statement will be executed, the statement is said to be unreachable.

Im BeispielIn the example

void F() {
    Console.WriteLine("reachable");
    goto Label;
    Console.WriteLine("unreachable");
    Label:
    Console.WriteLine("reachable");
}

der zweite Aufruf von Console.WriteLine ist nicht erreichbar, da besteht kein Risiko, dass die Anweisung ausgeführt wird.the second invocation of Console.WriteLine is unreachable because there is no possibility that the statement will be executed.

Eine Warnung wird ausgegeben, wenn der Compiler feststellt, dass eine Anweisung nicht erreichbar ist.A warning is reported if the compiler determines that a statement is unreachable. Es ist insbesondere nicht um einen Fehler für eine Anweisung als nicht erreichbar.It is specifically not an error for a statement to be unreachable.

Um zu bestimmen, ob eine bestimmte Anweisung oder der Endpunkt erreichbar ist, führt der Compiler Flussanalyse gemäß den Erreichbarkeitsregeln für jede Anweisung an.To determine whether a particular statement or end point is reachable, the compiler performs flow analysis according to the reachability rules defined for each statement. Die Flussanalyse berücksichtigt die Werte der Konstanten Ausdrücke (Konstante Ausdrücke), die das Verhalten der Anweisungen steuern, aber die möglichen Werte nicht Konstante Ausdrücke werden nicht berücksichtigt.The flow analysis takes into account the values of constant expressions (Constant expressions) that control the behavior of statements, but the possible values of non-constant expressions are not considered. Das heißt, für Zwecke der Ablaufsteuerungsanalyse, ein nicht konstanter Ausdruck eines bestimmten Typs gilt alle möglichen Werte dieses Typs haben.In other words, for purposes of control flow analysis, a non-constant expression of a given type is considered to have any possible value of that type.

Im BeispielIn the example

void F() {
    const int i = 1;
    if (i == 2) Console.WriteLine("unreachable");
}

der boolesche Ausdruck, der die if -Anweisung ist ein konstanter Ausdruck, weil beide Operanden aus der == Operator Konstanten sind.the boolean expression of the if statement is a constant expression because both operands of the == operator are constants. Wie der Konstante Ausdruck zur Kompilierzeit ausgewertet wird, den Wert erzeugt false, Console.WriteLine Aufruf gilt als nicht erreichbar.As the constant expression is evaluated at compile-time, producing the value false, the Console.WriteLine invocation is considered unreachable. Aber wenn i wird geändert, um eine lokale Variable.However, if i is changed to be a local variable

void F() {
    int i = 1;
    if (i == 2) Console.WriteLine("reachable");
}

die Console.WriteLine Aufruf gilt als erreichbar sind, auch wenn sich in der Praxis es nie ausgeführt wird.the Console.WriteLine invocation is considered reachable, even though, in reality, it will never be executed.

Die Block einer Funktion Element immer als erreichbar.The block of a function member is always considered reachable. Durch die Auswertung der nacheinander der Erreichbarkeitsregeln für jede Anweisung in einem Block, kann die Erreichbarkeit des jede angegebene Anweisung ermittelt werden.By successively evaluating the reachability rules of each statement in a block, the reachability of any given statement can be determined.

Im BeispielIn the example

void F(int x) {
    Console.WriteLine("start");
    if (x < 0) Console.WriteLine("negative");
}

die Erreichbarkeit des zweiten Console.WriteLine wird wie folgt bestimmt:the reachability of the second Console.WriteLine is determined as follows:

  • Die erste Console.WriteLine Ausdrucksanweisung erreichbar ist. da der Block der F Methode erreichbar ist.The first Console.WriteLine expression statement is reachable because the block of the F method is reachable.
  • Der Endpunkt des ersten Console.WriteLine Ausdrucksanweisung ist erreichbar, da die Anweisung erreichbar ist.The end point of the first Console.WriteLine expression statement is reachable because that statement is reachable.
  • Die if -Anweisung erreichbar ist, daran, dass das Ende des ersten Console.WriteLine Ausdrucksanweisung ist erreichbar.The if statement is reachable because the end point of the first Console.WriteLine expression statement is reachable.
  • Die zweite Console.WriteLine Ausdrucksanweisung erreichbar ist. da der boolesche Ausdruck, der die if Anweisung verfügt nicht über den konstanten Wert false.The second Console.WriteLine expression statement is reachable because the boolean expression of the if statement does not have the constant value false.

Es gibt zwei Situationen, in denen ein Fehler während der Kompilierung für den Endpunkt einer Anweisung erreichbar ist:There are two situations in which it is a compile-time error for the end point of a statement to be reachable:

  • Da die switch Anweisung ist einen Switch-Abschnitt auf "Fortfahren" mit dem nächsten Switch-Abschnitt nicht zulässig, es ist ein Fehler während der Kompilierung für den Endpunkt der Anweisungsliste einen Switch-Abschnitt erreichbar sein.Because the switch statement does not permit a switch section to "fall through" to the next switch section, it is a compile-time error for the end point of the statement list of a switch section to be reachable. Wenn dieser Fehler auftritt, ist es in der Regel ein Hinweis auf, die eine break Anweisung ist nicht vorhanden.If this error occurs, it is typically an indication that a break statement is missing.
  • Es ist ein Fehler während der Kompilierung für den Endpunkt des Codeblocks an ein Funktionsmember, der berechnet einen Wert als erreichbar sein.It is a compile-time error for the end point of the block of a function member that computes a value to be reachable. Wenn dieser Fehler auftritt, ist es in der Regel ein Hinweis auf, die eine return Anweisung ist nicht vorhanden.If this error occurs, it typically is an indication that a return statement is missing.

BlöckeBlocks

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.

block
    : '{' statement_list? '}'
    ;

Ein Block besteht aus einem optionalen Statement_list (Anweisung listet) in geschweiften Klammern.A block consists of an optional statement_list (Statement lists), enclosed in braces. Wenn die Anweisungsliste ausgelassen wird, wird der Block als leer sein. bezeichnet.If the statement list is omitted, the block is said to be empty.

Ein Block kann deklarationsanweisungen enthalten (deklarationsanweisungen).A block may contain declaration statements (Declaration statements). Im Rahmen einer lokalen Variable oder Konstante wird in einem Block deklariert der Block.The scope of a local variable or constant declared in a block is the block.

Ein Block ist wie folgt ausgeführt:A block is executed as follows:

  • Wenn der Block leer ist, wird die Steuerung an den Endpunkt des Blocks übergeben.If the block is empty, control is transferred to the end point of the block.
  • Wenn der Block nicht leer ist, wird die Steuerung an die Anweisungsliste übergeben.If the block is not empty, control is transferred to the statement list. Wenn und Steuerung am Ende der Anweisungsliste erreicht, wird die Steuerung an den Endpunkt des Blocks übergeben.When and if control reaches the end point of the statement list, control is transferred to the end point of the block.

Die Anweisungsliste eines Blocks ist erreichbar, wenn der Block erreicht werden kann.The statement list of a block is reachable if the block itself is reachable.

Der Endpunkt eines Blocks ist erreichbar, wenn der Block leer ist oder wenn der Endpunkt der Anweisungsliste erreichbar ist.The end point of a block is reachable if the block is empty or if the end point of the statement list is reachable.

Ein Block , enthält eine oder mehrere yield Anweisungen (die Yield-Anweisung) kein Iteratorblock aufgerufen wird.A block that contains one or more yield statements (The yield statement) is called an iterator block. Iteratorblöcke werden verwendet, um Funktionsmember als Iteratoren implementiert (Iteratoren).Iterator blocks are used to implement function members as iterators (Iterators). Es gelten zusätzlichen Einschränkungen gelten für Iteratorblöcke:Some additional restrictions apply to iterator blocks:

  • Es ist ein Fehler während der Kompilierung für eine return -Anweisung in einem Iteratorblock angezeigt (aber yield return -Anweisungen sind zulässig).It is a compile-time error for a return statement to appear in an iterator block (but yield return statements are permitted).
  • Es ist ein Fehler während der Kompilierung für die kein Iteratorblock einen unsicheren Kontext enthalten (nicht sicheren Kontexten).It is a compile-time error for an iterator block to contain an unsafe context (Unsafe contexts). Kein Iteratorblock definiert immer einen sicheren Kontext ein, auch wenn der Deklaration in einem unsicheren Kontext geschachtelt sind.An iterator block always defines a safe context, even when its declaration is nested in an unsafe context.

AnweisungslistenStatement lists

Ein Anweisungsliste besteht aus mindestens einer Anweisung, die in der Sequenz geschrieben wurden.A statement list consists of one or more statements written in sequence. Anweisungslisten kommen Blocks (Blöcke) und im Switch_blocks (der Switch-Anweisung).Statement lists occur in blocks (Blocks) and in switch_blocks (The switch statement).

statement_list
    : statement+
    ;

Eine Anweisungsliste wird durch Übergabe der Steuerung an die erste Anweisung ausgeführt.A statement list is executed by transferring control to the first statement. Wenn und Kontrolle über den Endpunkt einer Anweisung erreicht, wird die Steuerung an die nächste Anweisung übergeben.When and if control reaches the end point of a statement, control is transferred to the next statement. Wenn und Steuerung der Endpunkt der letzten Anweisung erreicht, wird die Steuerung an den Endpunkt der Anweisungsliste übergeben.When and if control reaches the end point of the last statement, control is transferred to the end point of the statement list.

Eine Anweisung in eine Anweisungsliste ist erreichbar, wenn mindestens eine der folgenden "true" ist:A statement in a statement list is reachable if at least one of the following is true:

  • Die Anweisung ist die erste Anweisung aus, und die Anweisungsliste selbst erreichbar ist.The statement is the first statement and the statement list itself is reachable.
  • Der Endpunkt der vorherigen Anweisung ist erreichbar.The end point of the preceding statement is reachable.
  • Die Anweisung ist eine Anweisung mit Bezeichnung und die Bezeichnung verweist auf einen erreichbaren goto Anweisung.The statement is a labeled statement and the label is referenced by a reachable goto statement.

Der Endpunkt eine Anweisungsliste ist erreichbar, wenn der Endpunkt, der die letzte Anweisung in der Liste erreicht werden kann.The end point of a statement list is reachable if the end point of the last statement in the list is reachable.

Die leere AnweisungThe empty statement

Ein Empty_statement hat keine Auswirkungen.An empty_statement does nothing.

empty_statement
    : ';'
    ;

Eine leere Anweisung wird verwendet, wenn es keine Vorgänge in einem Kontext ausgeführt werden, wenn eine Anweisung erforderlich ist.An empty statement is used when there are no operations to perform in a context where a statement is required.

Ausführung eine leere Anweisung wird einfach die Steuerung an den Endpunkt der Anweisung.Execution of an empty statement simply transfers control to the end point of the statement. Daher ist der Endpunkt, der eine leere Anweisung erreichbar, wenn die leere Anweisung erreichbar ist.Thus, the end point of an empty statement is reachable if the empty statement is reachable.

Eine leere Anweisung kann verwendet werden, wenn das Schreiben einer while -Anweisung mit einem null-Text:An empty statement can be used when writing a while statement with a null body:

bool ProcessMessage() {...}

void ProcessMessages() {
    while (ProcessMessage())
        ;
}

Darüber hinaus kann eine leere Anweisung verwendet werden, deklarieren Sie eine Bezeichnung direkt vor dem abschließenden "}" eines Blocks:Also, an empty statement can be used to declare a label just before the closing "}" of a block:

void F() {
    ...
    if (done) goto exit;
    ...
    exit: ;
}

Anweisungen mit BezeichnungLabeled statements

Ein Labeled_statement ermöglicht eine Anweisung eine Bezeichnung vorangestellt werden.A labeled_statement permits a statement to be prefixed by a label. Anweisungen mit Bezeichnung sind in Blöcken zulässig, aber Sie sind als eingebettete Anweisungen nicht zulässig.Labeled statements are permitted in blocks, but are not permitted as embedded statements.

labeled_statement
    : identifier ':' statement
    ;

Eine bezeichnete Anweisung deklariert eine Bezeichnung mit dem Namen durch die Bezeichner.A labeled statement declares a label with the name given by the identifier. Der Bereich einer Bezeichnung ist auf den ganzen Block in der die Bezeichnung deklariert ist, einschließlich aller geschachtelten Blöcke.The scope of a label is the whole block in which the label is declared, including any nested blocks. Es ist ein Fehler während der Kompilierung für zwei Bezeichnungen mit dem gleichen Namen, um überlappende Bereiche zu erhalten.It is a compile-time error for two labels with the same name to have overlapping scopes.

Eine Bezeichnung aus verwiesen werden kann goto Anweisungen (Goto-Anweisung) innerhalb des Bereichs der Bezeichnung.A label can be referenced from goto statements (The goto statement) within the scope of the label. Dies bedeutet, dass goto Anweisungen können Steuerelement innerhalb von Blöcken und Out-of-Blöcken, aber nie in Blöcke übertragen.This means that goto statements can transfer control within blocks and out of blocks, but never into blocks.

Bezeichnungen müssen ihre eigenen Deklarationsabschnitt und verursachen keine Konflikte mit anderen Bezeichnern.Labels have their own declaration space and do not interfere with other identifiers. Im BeispielThe example

int F(int x) {
    if (x >= 0) goto x;
    x = -x;
    x: return x;
}

gültig ist und verwendet den Namen des x als Parameter und eine Bezeichnung.is valid and uses the name x as both a parameter and a label.

Ausführung einer Anweisung mit Bezeichnung entspricht der Ausführung der Anweisung nach der Bezeichnung.Execution of a labeled statement corresponds exactly to execution of the statement following the label.

Zusätzlich zu der Erreichbarkeit von normalen ablaufsteuerung bereitgestellt wird, ist eine Anweisung mit Bezeichnung erreichbar, wenn die Bezeichnung einen erreichbaren verweist goto Anweisung.In addition to the reachability provided by normal flow of control, a labeled statement is reachable if the label is referenced by a reachable goto statement. (Ausnahme: Wenn eine goto -Anweisung ist innerhalb einer try , enthält eine finally Block und der Anweisung mit Bezeichnung befindet sich außerhalb der try, und den Endpunkt des der finally Block ist nicht erreichbar, und klicken Sie dann die Anweisung mit Bezeichnung ist nicht erreichbar goto Anweisung.)(Exception: If a goto statement is inside a try that includes a finally block, and the labeled statement is outside the try, and the end point of the finally block is unreachable, then the labeled statement is not reachable from that goto statement.)

DeklarationsanweisungenDeclaration statements

Ein Declaration_statement deklariert eine lokale Variable oder Konstante.A declaration_statement declares a local variable or constant. Deklarationsanweisungen sind in Blöcken zulässig, aber Sie sind als eingebettete Anweisungen nicht zulässig.Declaration statements are permitted in blocks, but are not permitted as embedded statements.

declaration_statement
    : local_variable_declaration ';'
    | local_constant_declaration ';'
    ;

Deklarationen von lokalen VariablenLocal variable declarations

Ein Local_variable_declaration deklariert eine oder mehrere lokale Variablen.A local_variable_declaration declares one or more local variables.

local_variable_declaration
    : local_variable_type local_variable_declarators
    ;

local_variable_type
    : type
    | 'var'
    ;

local_variable_declarators
    : local_variable_declarator
    | local_variable_declarators ',' local_variable_declarator
    ;

local_variable_declarator
    : identifier
    | identifier '=' local_variable_initializer
    ;

local_variable_initializer
    : expression
    | array_initializer
    | local_variable_initializer_unsafe
    ;

Die Local_variable_type von einem Local_variable_declaration direkt gibt den Typ der Variablen durch die Deklaration eingeführt wurden, oder gibt an, mit dem Bezeichner var , Der Typ sollte basierend auf einem Initialisierer abgeleitet werden.The local_variable_type of a local_variable_declaration either directly specifies the type of the variables introduced by the declaration, or indicates with the identifier var that the type should be inferred based on an initializer. Der Typ folgt eine Liste der Local_variable_declarators, von denen jede eine neue Variable führt.The type is followed by a list of local_variable_declarators, each of which introduces a new variable. Ein Local_variable_declarator besteht aus einer Bezeichner mit dem Namen der Variablen, optional gefolgt von einer "=" token und einem Local_variable_initializer , durch den Anfangswert der Variablen erhalten.A local_variable_declarator consists of an identifier that names the variable, optionally followed by an "=" token and a local_variable_initializer that gives the initial value of the variable.

Im Kontext der Deklaration einer lokalen Variablen, Var Bezeichner fungiert, als ein kontextbezogenes Schlüsselwort (Schlüsselwörter). Bei der Local_variable_type angegeben ist, als var und kein Typ mit dem Namen var ist im Gültigkeitsbereich die Deklaration ist eine implizit typisierten Deklaration lokalen Variablen, dessen Typ abgeleitet aus dem Typ des initialisiererausdrucks zugeordnet.In the context of a local variable declaration, the identifier var acts as a contextual keyword (Keywords).When the local_variable_type is specified as var and no type named var is in scope, the declaration is an implicitly typed local variable declaration, whose type is inferred from the type of the associated initializer expression. Implizit typisierte lokale Variable Deklarationen sind jedoch mit folgenden Einschränkungen:Implicitly typed local variable declarations are subject to the following restrictions:

  • Die Local_variable_declaration kann nicht mehrere enthalten Local_variable_declarators.The local_variable_declaration cannot include multiple local_variable_declarators.
  • Die Local_variable_declarator müssen eine Local_variable_initializer.The local_variable_declarator must include a local_variable_initializer.
  • Die Local_variable_initializer muss ein Ausdruck.The local_variable_initializer must be an expression.
  • Der Initialisierer Ausdruck muss eine während der Kompilierung aufweisen.The initializer expression must have a compile-time type.
  • Der Initialisierer Ausdruck kann nicht auf die deklarierte Variable sich selbst verweisenThe initializer expression cannot refer to the declared variable itself

Es folgen Beispiele für falsche implizit typisierte lokale Variable Deklarationen:The following are examples of incorrect implicitly typed local variable declarations:

var x;               // Error, no initializer to infer type from
var y = {1, 2, 3};   // Error, array initializer not permitted
var z = null;        // Error, null does not have a type
var u = x => x + 1;  // Error, anonymous functions do not have a type
var v = v++;         // Error, initializer cannot refer to variable itself

Der Wert einer lokalen Variablen wird abgerufen, in einem Ausdruck mit einer Simple_name (einfache Namen), sowie der Wert einer lokalen Variablen mit geändert wird ein Zuweisung ( Zuweisungsoperatoren).The value of a local variable is obtained in an expression using a simple_name (Simple names), and the value of a local variable is modified using an assignment (Assignment operators). Eine lokale Variable muss definitiv zugewiesen werden (definitive Zuweisung) an jedem Standort, bei dem der Wert abgerufen wird.A local variable must be definitely assigned (Definite assignment) at each location where its value is obtained.

Eine lokale Variable deklariert, die im Rahmen einer Local_variable_declaration ist der Block in dem die Deklaration erfolgt.The scope of a local variable declared in a local_variable_declaration is the block in which the declaration occurs. Es ist ein Fehler auf Sie verweisen auf eine lokale Variable in der Lage, Text vor dem Local_variable_declarator der lokalen Variablen.It is an error to refer to a local variable in a textual position that precedes the local_variable_declarator of the local variable. Innerhalb des Bereichs einer lokalen Variablen ist es ein Fehler während der Kompilierung eine andere lokale Variable oder Konstante mit dem gleichen Namen deklariert.Within the scope of a local variable, it is a compile-time error to declare another local variable or constant with the same name.

Die Deklaration eine lokale Variable, die mehrere Variablen deklariert entspricht mehreren Deklarationen der einzelnen Variablen mit dem gleichen Typ.A local variable declaration that declares multiple variables is equivalent to multiple declarations of single variables with the same type. Darüber hinaus entspricht einem Variableninitialisierer in einer lokalen Variablendeklaration genau einer zuweisungsanweisung, die sofort nach der Deklaration eingefügt wird.Furthermore, a variable initializer in a local variable declaration corresponds exactly to an assignment statement that is inserted immediately after the declaration.

Im BeispielThe example

void F() {
    int x = 1, y, z = x * 2;
}

genau entsprichtcorresponds exactly to

void F() {
    int x; x = 1;
    int y;
    int z; z = x * 2;
}

In einer implizit typisierten lokalen Variablendeklaration wird der Typ der deklarierten lokalen Variablen erstellt, um den Typ des Ausdrucks verwendet, um die Variable initialisieren identisch sein.In an implicitly typed local variable declaration, the type of the local variable being declared is taken to be the same as the type of the expression used to initialize the variable. Zum Beispiel:For example:

var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary<int,Order>();

Implizit typisierten lokalen Variablendeklarationen oben sind die folgenden explizit typisierten Deklarationen genaue Entsprechung:The implicitly typed local variable declarations above are precisely equivalent to the following explicitly typed declarations:

int i = 5;
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary<int,Order> orders = new Dictionary<int,Order>();

Deklaration von lokalen KonstantenLocal constant declarations

Ein Local_constant_declaration eine oder mehrere lokale Konstanten deklariert.A local_constant_declaration declares one or more local constants.

local_constant_declaration
    : 'const' type constant_declarators
    ;

constant_declarators
    : constant_declarator (',' constant_declarator)*
    ;

constant_declarator
    : identifier '=' constant_expression
    ;

Die Typ von einem Local_constant_declaration gibt den Typ der Konstanten, die durch die Deklaration eingeführt.The type of a local_constant_declaration specifies the type of the constants introduced by the declaration. Der Typ folgt eine Liste der Constant_declarators, von denen jede eine neue Konstante führt.The type is followed by a list of constant_declarators, each of which introduces a new constant. Ein Constant_declarator besteht aus einer Bezeichner , Namen der Konstanten gefolgt von einer "=" token, gefolgt von einer Constant_expression ( Konstante Ausdrücke), die den Wert der Konstanten bietet.A constant_declarator consists of an identifier that names the constant, followed by an "=" token, followed by a constant_expression (Constant expressions) that gives the value of the constant.

Die Typ und Constant_expression der Deklaration von lokalen Konstanten muss, gelten dieselben Regeln wie für eine Deklaration einer Konstante Member (Konstanten).The type and constant_expression of a local constant declaration must follow the same rules as those of a constant member declaration (Constants).

Der Wert einer lokalen Konstanten wird ermittelt, in einem Ausdruck mit einem Simple_name (einfache Namen).The value of a local constant is obtained in an expression using a simple_name (Simple names).

Der Gültigkeitsbereich der lokale Konstante ist, den Block in dem die Deklaration erfolgt.The scope of a local constant is the block in which the declaration occurs. Es ist ein Fehler auf Sie verweisen auf eine lokale Konstante in der Lage, Text vor dessen Constant_declarator.It is an error to refer to a local constant in a textual position that precedes its constant_declarator. Innerhalb des Bereichs einer lokalen Konstanten ist es ein Fehler während der Kompilierung eine andere lokale Variable oder Konstante mit dem gleichen Namen deklariert.Within the scope of a local constant, it is a compile-time error to declare another local variable or constant with the same name.

Deklaration von lokale Konstante, die mehrere Konstanten deklariert entspricht mehreren Deklarationen der einzelnen Konstanten desselben Typs.A local constant declaration that declares multiple constants is equivalent to multiple declarations of single constants with the same type.

AusdrucksanweisungenExpression statements

Ein Expression_statement wertet einen angegebenen Ausdruck.An expression_statement evaluates a given expression. Der Wert berechnet werden, durch den Ausdruck wird ggf. verworfen.The value computed by the expression, if any, is discarded.

expression_statement
    : statement_expression ';'
    ;

statement_expression
    : invocation_expression
    | null_conditional_invocation_expression
    | object_creation_expression
    | assignment
    | post_increment_expression
    | post_decrement_expression
    | pre_increment_expression
    | pre_decrement_expression
    | await_expression
    ;

Nicht alle Ausdrücke werden als Anweisungen zulässig.Not all expressions are permitted as statements. Insbesondere Ausdrücke wie z. B. x + y und x == 1 , die lediglich einen Wert (die werden verworfen) berechnen, werden als Anweisungen nicht zulässig.In particular, expressions such as x + y and x == 1 that merely compute a value (which will be discarded), are not permitted as statements.

Ausführung einer Expression_statement der enthaltenen Ausdruck ausgewertet, und klicken Sie dann überträgt die Steuerung an den Endpunkt, der die Expression_statement.Execution of an expression_statement evaluates the contained expression and then transfers control to the end point of the expression_statement. Der Endpunkt, der eine Expression_statement ist erreichbar. wenn das Expression_statement erreichbar ist.The end point of an expression_statement is reachable if that expression_statement is reachable.

AuswahlanweisungenSelection statements

Auswahlanweisungen wählen Sie eine Anzahl von möglichen Anweisungen für die Ausführung anhand des Werts eines Ausdrucks.Selection statements select one of a number of possible statements for execution based on the value of some expression.

selection_statement
    : if_statement
    | switch_statement
    ;

Die bei AnweisungThe if statement

Die if -Anweisung wählt eine Anweisung für die Ausführung anhand des Werts eines booleschen Ausdrucks.The if statement selects a statement for execution based on the value of a boolean expression.

if_statement
    : 'if' '(' boolean_expression ')' embedded_statement
    | 'if' '(' boolean_expression ')' embedded_statement 'else' embedded_statement
    ;

Ein else Teil bezieht sich auf dem lexikalisch nächsten vorausgehenden if , durch die Syntax zulässig ist.An else part is associated with the lexically nearest preceding if that is allowed by the syntax. Daher eine if -Anweisung der FormThus, an if statement of the form

if (x) if (y) F(); else G();

für die folgende Syntax:is equivalent to

if (x) {
    if (y) {
        F();
    }
    else {
        G();
    }
}

Ein if -Anweisung wird wie folgt ausgeführt:An if statement is executed as follows:

  • Die Boolean_expression (boolesche Ausdrücke) ausgewertet wird.The boolean_expression (Boolean expressions) is evaluated.
  • Wenn der boolesche Ausdruck ergibt true, wird die Steuerung an die erste eingebettete Anweisung.If the boolean expression yields true, control is transferred to the first embedded statement. Wenn und Steuerung der Endpunkt, der diese Anweisung erreicht, wird die Steuerung an den Endpunkt der if Anweisung.When and if control reaches the end point of that statement, control is transferred to the end point of the if statement.
  • Wenn der boolesche Ausdruck ergibt false und, wenn ein else Teil vorhanden ist, wird die Steuerung an die zweite, eingebettete Anweisung.If the boolean expression yields false and if an else part is present, control is transferred to the second embedded statement. Wenn und Steuerung der Endpunkt, der diese Anweisung erreicht, wird die Steuerung an den Endpunkt der if Anweisung.When and if control reaches the end point of that statement, control is transferred to the end point of the if statement.
  • Wenn der boolesche Ausdruck ergibt false und, wenn ein else Teil ist nicht vorhanden, wird die Steuerung an den Endpunkt, der die if Anweisung.If the boolean expression yields false and if an else part is not present, control is transferred to the end point of the if statement.

Die erste eingebettete Anweisung, der ein if Anweisung erreichbar ist. wenn die if -Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert false.The first embedded statement of an if statement is reachable if the if statement is reachable and the boolean expression does not have the constant value false.

Die zweite eingebettete Anweisung, die von einer if -Anweisung, falls vorhanden, ist erreichbar Wenn die if -Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert true.The second embedded statement of an if statement, if present, is reachable if the if statement is reachable and the boolean expression does not have the constant value true.

Der Endpunkt, der eine if -Anweisung ist erreichbar, wenn der Endpunkt, der mindestens eines der eingebetteten Anweisungen erreichbar ist.The end point of an if statement is reachable if the end point of at least one of its embedded statements is reachable. Darüber hinaus zeigen Sie das Ende des ein if Anweisung ohne else Teil erreichbar ist. wenn die if -Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert true.In addition, the end point of an if statement with no else part is reachable if the if statement is reachable and the boolean expression does not have the constant value true.

Der Switch-AnweisungThe switch statement

Die Switch-Anweisung wählt eine Anweisungsliste mit einer zugeordneten Switch-Bezeichnung, die den Wert des Switch-Ausdrucks entspricht, für die Ausführung.The switch statement selects for execution a statement list having an associated switch label that corresponds to the value of the switch expression.

switch_statement
    : 'switch' '(' expression ')' switch_block
    ;

switch_block
    : '{' switch_section* '}'
    ;

switch_section
    : switch_label+ statement_list
    ;

switch_label
    : 'case' constant_expression ':'
    | 'default' ':'
    ;

Ein Switch_statement besteht aus dem Schlüsselwort switch, gefolgt von einem Ausdruck in Klammern (den Switch-Ausdruck bezeichnet), gefolgt von einem Switch_block.A switch_statement consists of the keyword switch, followed by a parenthesized expression (called the switch expression), followed by a switch_block. Die Switch_block besteht aus 0 (null) oder mehreren Switch_sections, die in geschweifte Klammern eingeschlossen.The switch_block consists of zero or more switch_sections, enclosed in braces. Jede Switch_section besteht aus einem oder mehreren Switch_labels gefolgt von einem Statement_list (Anweisung listet).Each switch_section consists of one or more switch_labels followed by a statement_list (Statement lists).

Die für Typ von einem switch Anweisung wird hergestellt, indem der Switch-Ausdruck.The governing type of a switch statement is established by the switch expression.

  • Wenn der Typ des Switch-Ausdrucks ist sbyte, byte, short, ushort, int, uint, long, ulong, bool, char, string, oder ein Enum_type, oder wenn es für einen dieser Typen einen nullable-Typ ist, dann wird die Steuerung zu geben, der die switch Anweisung.If the type of the switch expression is sbyte, byte, short, ushort, int, uint, long, ulong, bool, char, string, or an enum_type, or if it is the nullable type corresponding to one of these types, then that is the governing type of the switch statement.
  • Andernfalls genau eine benutzerdefinierte implizite Konvertierung (benutzerdefinierte Konvertierungen) muss vorhanden sein, von dem Typ des Switch-Ausdrucks auf einen der folgenden möglichen Typen, die steuern: sbyte, byte, short , ushort, int, uint, long, ulong, char, string, oder einen nullable-Typ, der einer dieser Typen entspricht.Otherwise, exactly one user-defined implicit conversion (User-defined conversions) must exist from the type of the switch expression to one of the following possible governing types: sbyte, byte, short, ushort, int, uint, long, ulong, char, string, or, a nullable type corresponding to one of those types.
  • Andernfalls tritt auf, wenn solch eine implizite Konvertierung vorhanden ist oder wenn mehr als eine implizite Konvertierung vorhanden ist, ein Fehler während der Kompilierung.Otherwise, if no such implicit conversion exists, or if more than one such implicit conversion exists, a compile-time error occurs.

Der Konstante Ausdruck jeder case Bezeichnung muss einen Wert, der implizit konvertiert werden deuten (implizite Konvertierungen) auf der vorherrschende Datentyp der switch Anweisung.The constant expression of each case label must denote a value that is implicitly convertible (Implicit conversions) to the governing type of the switch statement. Ein Fehler während der Kompilierung tritt auf, wenn zwei oder mehr case Bezeichnungen in der gleichen switch Anweisung geben Sie den konstanten Wert.A compile-time error occurs if two or more case labels in the same switch statement specify the same constant value.

Es kann höchstens eine default Bezeichnung in einer Switch-Anweisung.There can be at most one default label in a switch statement.

Ein switch -Anweisung wird wie folgt ausgeführt:A switch statement is executed as follows:

  • Der Switch-Ausdruck wird ausgewertet und in der vorherrschende Datentyp konvertiert.The switch expression is evaluated and converted to the governing type.
  • Wenn eine der Konstanten in angegeben ein case Bezeichnung in der gleichen switch -Anweisung ist gleich dem Wert des Switch-Ausdrucks, die Steuerung an die Anweisungsliste, die nach der entsprechenden case Bezeichnung.If one of the constants specified in a case label in the same switch statement is equal to the value of the switch expression, control is transferred to the statement list following the matched case label.
  • Wenn keine der Konstanten in angegebenen case Bezeichnungen in der gleichen switch -Anweisung ist gleich dem Wert des Switch-Ausdrucks, und wenn ein default Bezeichnung vorhanden ist, wird die Steuerung an die Anweisung Liste nach der default Bezeichnung.If none of the constants specified in case labels in the same switch statement is equal to the value of the switch expression, and if a default label is present, control is transferred to the statement list following the default label.
  • Wenn keine der Konstanten in angegebenen case Bezeichnungen in der gleichen switch -Anweisung ist gleich dem Wert des Switch-Ausdrucks, und wenn keine default Bezeichnung vorhanden ist, wird die Steuerung an den Endpunkt der switch Anweisung.If none of the constants specified in case labels in the same switch statement is equal to the value of the switch expression, and if no default label is present, control is transferred to the end point of the switch statement.

Wenn der Endpunkt der Anweisungsliste einen Switch-Abschnitt erreichbar ist, tritt ein Fehler während der Kompilierung.If the end point of the statement list of a switch section is reachable, a compile-time error occurs. Dies wird wie in der Regel "keine fortfahren" bezeichnet.This is known as the "no fall through" rule. Im BeispielThe example

switch (i) {
case 0:
    CaseZero();
    break;
case 1:
    CaseOne();
    break;
default:
    CaseOthers();
    break;
}

ist gültig, da keine Switch-Abschnitt auf einen erreichbaren Endpunkt enthält.is valid because no switch section has a reachable end point. Im Gegensatz zu C und C++ Ausführung ein Switch-Abschnitt darf nicht "Fortfahren" zu den nächsten Switch-Abschnitt im BeispielUnlike C and C++, execution of a switch section is not permitted to "fall through" to the next switch section, and the example

switch (i) {
case 0:
    CaseZero();
case 1:
    CaseZeroOrOne();
default:
    CaseAny();
}

führt zu einem Fehler während der Kompilierung.results in a compile-time error. Bei Ausführung des ein Switch-Abschnitt ist durch die Ausführung von einem anderen Switch-Abschnitt, eine explizite befolgt werden goto case oder goto default -Anweisung verwendet werden muss:When execution of a switch section is to be followed by execution of another switch section, an explicit goto case or goto default statement must be used:

switch (i) {
case 0:
    CaseZero();
    goto case 1;
case 1:
    CaseZeroOrOne();
    goto default;
default:
    CaseAny();
    break;
}

Mehrere Bezeichnungen dürfen sich einem Switch_section.Multiple labels are permitted in a switch_section. Im BeispielThe example

switch (i) {
case 0:
    CaseZero();
    break;
case 1:
    CaseOne();
    break;
case 2:
default:
    CaseTwo();
    break;
}

ist gültig.is valid. Im Beispiel wird die Regel "keine fortfahren" nicht verletzt, da die Bezeichnungen case 2: und default: sind Teil derselben Switch_section.The example does not violate the "no fall through" rule because the labels case 2: and default: are part of the same switch_section.

Die Regel "keine fortfahren" wird verhindert, dass eine allgemeine Klasse von Fehlern, die in C und C++ auftreten, wenn break Anweisungen versehentlich ausgelassen werden.The "no fall through" rule prevents a common class of bugs that occur in C and C++ when break statements are accidentally omitted. Darüber hinaus aufgrund dieser Regel, die Switch-Abschnitte von einem switch Anweisung willkürlich neu angeordnet werden kann ohne Auswirkungen auf das Verhalten der Anweisung.In addition, because of this rule, the switch sections of a switch statement can be arbitrarily rearranged without affecting the behavior of the statement. Z. B. die Abschnitte der switch obigen Anweisung ohne Auswirkungen auf das Verhalten der Anweisung rückgängig gemacht werden kann:For example, the sections of the switch statement above can be reversed without affecting the behavior of the statement:

switch (i) {
default:
    CaseAny();
    break;
case 1:
    CaseZeroOrOne();
    goto default;
case 0:
    CaseZero();
    goto case 1;
}

In der Regel die Anweisungsliste, der ein Switch-Abschnitt endet, in einem break, goto case, oder goto default -Anweisung, jedoch Konstrukt, das am Ende der Anweisungsliste unerreichbar ist zulässig.The statement list of a switch section typically ends in a break, goto case, or goto default statement, but any construct that renders the end point of the statement list unreachable is permitted. Z. B. eine while Anweisung, die von der boolesche Ausdruck gesteuert true nie Reichweite seinen Endpunkt bekannt ist.For example, a while statement controlled by the boolean expression true is known to never reach its end point. Ebenso eine throw oder return -Anweisung immer überträgt die Steuerung an anderer Stelle und seinen Endpunkt nicht erreicht.Likewise, a throw or return statement always transfers control elsewhere and never reaches its end point. Im folgende Beispiel ist daher gültig:Thus, the following example is valid:

switch (i) {
case 0:
    while (true) F();
case 1:
    throw new ArgumentException();
case 2:
    return;
}

Der vorherrschende Datentyp eine switch Anweisung kann es sich um den Typ string.The governing type of a switch statement may be the type string. Zum Beispiel:For example:

void DoCommand(string command) {
    switch (command.ToLower()) {
    case "run":
        DoRun();
        break;
    case "save":
        DoSave();
        break;
    case "quit":
        DoQuit();
        break;
    default:
        InvalidCommand(command);
        break;
    }
}

Wie die Gleichheitsoperatoren (Zeichenfolge Gleichheitsoperatoren), wird die switch -Anweisung wird die Groß-/Kleinschreibung beachtet und einen bestimmten Switch-Abschnitt nur ausgeführt, wenn die Zeichenfolge des Switch-Ausdrucks identisch eine case Bezeichnung Konstante.Like the string equality operators (String equality operators), the switch statement is case sensitive and will execute a given switch section only if the switch expression string exactly matches a case label constant.

Wenn der Typ den leitenden eine switch -Anweisung ist string, den Wert null als Konstante Case-Bezeichnung zulässig ist.When the governing type of a switch statement is string, the value null is permitted as a case label constant.

Die Statement_lists eine Switch_block darf deklarationsanweisungen (deklarationsanweisungen).The statement_lists of a switch_block may contain declaration statements (Declaration statements). Im Rahmen einer lokalen Variable oder Konstante wird, die in einer Switch-Block deklariert der Switch-Block.The scope of a local variable or constant declared in a switch block is the switch block.

Die Anweisungsliste, der einem bestimmten Switch-Abschnitt ist erreichbar. wenn die switch -Anweisung erreichbar ist und mindestens eine der folgenden gilt:The statement list of a given switch section is reachable if the switch statement is reachable and at least one of the following is true:

  • Der Switch-Ausdruck ist ein nicht konstanter Wert.The switch expression is a non-constant value.
  • Der Switch-Ausdruck ist ein konstanter Wert, der entspricht einem case Bezeichnung im Switch-Abschnitt.The switch expression is a constant value that matches a case label in the switch section.
  • Der Switch-Ausdruck ist ein konstanter Wert, der bundesstaatscode keiner entspricht case Bezeichnung und Switch-Abschnitt enthält die default Bezeichnung.The switch expression is a constant value that doesn't match any case label, and the switch section contains the default label.
  • Eine Switch-Bezeichnung der Switch-Abschnitt verweist auf einen erreichbaren goto case oder goto default Anweisung.A switch label of the switch section is referenced by a reachable goto case or goto default statement.

Der Endpunkt, der eine switch -Anweisung ist erreichbar, wenn mindestens eine der folgenden "true" ist:The end point of a switch statement is reachable if at least one of the following is true:

  • Die switch -Anweisung enthält einen erreichbaren break -Anweisung, die beendet die switch Anweisung.The switch statement contains a reachable break statement that exits the switch statement.
  • Die switch -Anweisung erreichbar ist, der Switch-Ausdruck ist ein nicht konstanter Wert und keine default -Bezeichnung ist vorhanden.The switch statement is reachable, the switch expression is a non-constant value, and no default label is present.
  • Die switch -Anweisung erreichbar ist, der Switch-Ausdruck ist ein konstanter Wert, der bundesstaatscode keiner entspricht case Bezeichnung und ohne default -Bezeichnung ist vorhanden.The switch statement is reachable, the switch expression is a constant value that doesn't match any case label, and no default label is present.

IterationsanweisungenIteration statements

Iterationsanweisungen hat eine eingebettete Anweisung wiederholt ausführen.Iteration statements repeatedly execute an embedded statement.

iteration_statement
    : while_statement
    | do_statement
    | for_statement
    | foreach_statement
    ;

Die while-AnweisungThe while statement

Die while Anweisung führt bedingt eine eingebettete Anweisung nullmal oder häufiger abgeglichen.The while statement conditionally executes an embedded statement zero or more times.

while_statement
    : 'while' '(' boolean_expression ')' embedded_statement
    ;

Ein while -Anweisung wird wie folgt ausgeführt:A while statement is executed as follows:

  • Die Boolean_expression (boolesche Ausdrücke) ausgewertet wird.The boolean_expression (Boolean expressions) is evaluated.
  • Wenn der boolesche Ausdruck ergibt true, wird die Steuerung an die eingebettete Anweisung.If the boolean expression yields true, control is transferred to the embedded statement. Wenn und die Steuerung der Endpunkt, der die eingebettete Anweisung erreicht (möglicherweise durch Ausführen von einer continue Anweisung), wird die Steuerung an den Anfang der while Anweisung.When and if control reaches the end point of the embedded statement (possibly from execution of a continue statement), control is transferred to the beginning of the while statement.
  • Wenn der boolesche Ausdruck ergibt false, die Steuerung an den Endpunkt der while Anweisung.If the boolean expression yields false, control is transferred to the end point of the while statement.

In der die eingebettete Anweisung eine while -Anweisung eine break Anweisung (die Break-Anweisung) kann verwendet werden, die Steuerung an den Endpunkt übertragen die while (also mit der Endung Iteration, der die eingebettete Anweisung -Anweisung), und ein continue Anweisung (die Continue-Anweisung) kann verwendet werden, um die Steuerung an den Endpunkt, der die eingebettete Anweisung zu übertragen (daher Ausführen einer anderen Iteration von der while Anweisung).Within the embedded statement of a while statement, a break statement (The break statement) may be used to transfer control to the end point of the while statement (thus ending iteration of the embedded statement), and a continue statement (The continue statement) may be used to transfer control to the end point of the embedded statement (thus performing another iteration of the while statement).

Die eingebettete Anweisung, der eine while Anweisung erreichbar ist. wenn die while -Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert false.The embedded statement of a while statement is reachable if the while statement is reachable and the boolean expression does not have the constant value false.

Der Endpunkt, der eine while -Anweisung ist erreichbar, wenn mindestens eine der folgenden "true" ist:The end point of a while statement is reachable if at least one of the following is true:

  • Die while -Anweisung enthält einen erreichbaren break -Anweisung, die beendet die while Anweisung.The while statement contains a reachable break statement that exits the while statement.
  • Die while -Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert true.The while statement is reachable and the boolean expression does not have the constant value true.

Die Do-AnweisungThe do statement

Die do Anweisung führt bedingt eine eingebettete Anweisung einmal oder mehrmals.The do statement conditionally executes an embedded statement one or more times.

do_statement
    : 'do' embedded_statement 'while' '(' boolean_expression ')' ';'
    ;

Ein do -Anweisung wird wie folgt ausgeführt:A do statement is executed as follows:

  • Steuerung wird an die eingebettete Anweisung übergeben.Control is transferred to the embedded statement.
  • Wenn und die Steuerung der Endpunkt, der die eingebettete Anweisung erreicht (möglicherweise durch Ausführen von einer continue Anweisung), wird die Boolean_expression (boolesche Ausdrücke) ausgewertet wird.When and if control reaches the end point of the embedded statement (possibly from execution of a continue statement), the boolean_expression (Boolean expressions) is evaluated. Wenn der boolesche Ausdruck ergibt true, wird die Steuerung an den Anfang der do Anweisung.If the boolean expression yields true, control is transferred to the beginning of the do statement. Andernfalls wird die Steuerung an den Endpunkt, der die do Anweisung.Otherwise, control is transferred to the end point of the do statement.

In der die eingebettete Anweisung eine do -Anweisung eine break Anweisung (die Break-Anweisung) kann verwendet werden, die Steuerung an den Endpunkt übertragen die do (also mit der Endung Iteration, der die eingebettete Anweisung -Anweisung), und ein continue Anweisung (die Continue-Anweisung) kann verwendet werden, um die Steuerung an den Endpunkt, der die eingebettete Anweisung zu übertragen.Within the embedded statement of a do statement, a break statement (The break statement) may be used to transfer control to the end point of the do statement (thus ending iteration of the embedded statement), and a continue statement (The continue statement) may be used to transfer control to the end point of the embedded statement.

Die eingebettete Anweisung des eine do Anweisung erreichbar ist. wenn die do -Anweisung erreichbar ist.The embedded statement of a do statement is reachable if the do statement is reachable.

Der Endpunkt, der eine do -Anweisung ist erreichbar, wenn mindestens eine der folgenden "true" ist:The end point of a do statement is reachable if at least one of the following is true:

  • Die do -Anweisung enthält einen erreichbaren break -Anweisung, die beendet die do Anweisung.The do statement contains a reachable break statement that exits the do statement.
  • Der Endpunkt, der die eingebettete Anweisung erreichbar ist und der boolesche Ausdruck verfügt nicht über den konstanten Wert true.The end point of the embedded statement is reachable and the boolean expression does not have the constant value true.

Die für die AnweisungThe for statement

Die for Anweisung wertet eine Reihe von Initialisierungsausdrücken und dann, solange eine Bedingung "true" wird wiederholt führt eine eingebettete Anweisung und eine Sequenz von Ausdrücken für Iteration ausgewertet.The for statement evaluates a sequence of initialization expressions and then, while a condition is true, repeatedly executes an embedded statement and evaluates a sequence of iteration expressions.

for_statement
    : 'for' '(' for_initializer? ';' for_condition? ';' for_iterator? ')' embedded_statement
    ;

for_initializer
    : local_variable_declaration
    | statement_expression_list
    ;

for_condition
    : boolean_expression
    ;

for_iterator
    : statement_expression_list
    ;

statement_expression_list
    : statement_expression (',' statement_expression)*
    ;

Die For_initializer, falls vorhanden, besteht entweder aus einem Local_variable_declaration (lokale Variablendeklarationen) oder eine Liste von Statement_ Ausdrucks (ausdrucksanweisungen) durch Kommas getrennt.The for_initializer, if present, consists of either a local_variable_declaration (Local variable declarations) or a list of statement_expressions (Expression statements) separated by commas. Der Bereich, der eine lokale Variable deklariert, indem eine For_initializer beginnt bei der Local_variable_declarator für die Variable und reicht bis zum Ende der embedded-Anweisung.The scope of a local variable declared by a for_initializer starts at the local_variable_declarator for the variable and extends to the end of the embedded statement. Der Gültigkeitsbereich umfasst die For_condition und For_iterator.The scope includes the for_condition and the for_iterator.

Die For_condition, falls vorhanden, muss ein Boolean_expression (boolesche Ausdrücke).The for_condition, if present, must be a boolean_expression (Boolean expressions).

Die For_iterator, falls vorhanden, besteht aus einer Liste von Statement_expressions (ausdrucksanweisungen) durch Kommas getrennt.The for_iterator, if present, consists of a list of statement_expressions (Expression statements) separated by commas.

Eine for-Anweisung wird wie folgt ausgeführt:A for statement is executed as follows:

  • Wenn eine For_initializer ist vorhanden, wird die Variable Initialisierer oder Anweisungsausdrücke ausgeführt werden, in der Reihenfolge, die sie geschrieben werden.If a for_initializer is present, the variable initializers or statement expressions are executed in the order they are written. Dieser Schritt ist nur einmal ausgeführt.This step is only performed once.
  • Wenn eine For_condition vorhanden ist, wird ausgewertet.If a for_condition is present, it is evaluated.
  • Wenn die For_condition nicht vorhanden ist oder wenn das Ergebnis der Auswertung true, wird die Steuerung an die eingebettete Anweisung.If the for_condition is not present or if the evaluation yields true, control is transferred to the embedded statement. Wenn und die Steuerung der Endpunkt, der die eingebettete Anweisung erreicht (möglicherweise durch Ausführen von eine continue Anweisung), die Ausdrücke der For_iterator, sofern vorhanden, werden in der Reihenfolge ausgewertet, und klicken Sie dann eine andere Iteration ist durchgeführt, beginnend mit der Auswertung der For_condition im vorherigen Schritt.When and if control reaches the end point of the embedded statement (possibly from execution of a continue statement), the expressions of the for_iterator, if any, are evaluated in sequence, and then another iteration is performed, starting with evaluation of the for_condition in the step above.
  • Wenn die For_condition vorhanden ist und die Auswertung ergibt false, die Steuerung an den Endpunkt der for Anweisung.If the for_condition is present and the evaluation yields false, control is transferred to the end point of the for statement.

In der die eingebettete Anweisung eine for -Anweisung eine break Anweisung (die Break-Anweisung) kann verwendet werden, die Steuerung an den Endpunkt übertragen die for (also mit der Endung Iteration, der die eingebettete Anweisung -Anweisung), und ein continue Anweisung (die Continue-Anweisung) kann verwendet werden, um die Steuerung an den Endpunkt, der die eingebettete Anweisung zu übertragen (somit Ausführen der For_iterator und Ausführen einer anderen Iteration, der die for -Anweisung, beginnend mit der For_condition).Within the embedded statement of a for statement, a break statement (The break statement) may be used to transfer control to the end point of the for statement (thus ending iteration of the embedded statement), and a continue statement (The continue statement) may be used to transfer control to the end point of the embedded statement (thus executing the for_iterator and performing another iteration of the for statement, starting with the for_condition).

Die eingebettete Anweisung von einem for -Anweisung ist erreichbar, wenn eine der folgenden Aussagen zutrifft:The embedded statement of a for statement is reachable if one of the following is true:

  • Die for -Anweisung erreichbar ist und es wird kein For_condition vorhanden ist.The for statement is reachable and no for_condition is present.
  • Die for -Anweisung erreichbar ist und ein For_condition vorhanden ist und keine den konstanten Wert false.The for statement is reachable and a for_condition is present and does not have the constant value false.

Der Endpunkt, der eine for -Anweisung ist erreichbar, wenn mindestens eine der folgenden "true" ist:The end point of a for statement is reachable if at least one of the following is true:

  • Die for -Anweisung enthält einen erreichbaren break -Anweisung, die beendet die for Anweisung.The for statement contains a reachable break statement that exits the for statement.
  • Die for -Anweisung erreichbar ist und ein For_condition vorhanden ist und keine den konstanten Wert true.The for statement is reachable and a for_condition is present and does not have the constant value true.

Die Foreach-AnweisungThe foreach statement

Die foreach Anweisung listet die Elemente einer Auflistung und führt eine eingebettete Anweisung für jedes Element der Auflistung.The foreach statement enumerates the elements of a collection, executing an embedded statement for each element of the collection.

foreach_statement
    : 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement
    ;

Die Typ und Bezeichner von einer foreach Anweisung deklariert den Iterationsvariable der Anweisung.The type and identifier of a foreach statement declare the iteration variable of the statement. Wenn die var Bezeichner angegeben wird, als die Local_variable_type, und kein Typ mit dem Namen var ist im Gültigkeitsbereich der Iterationsvariablen gilt eine implizit typisierte Iterationsvariable, und sein Typ wird erstellt, um den Elementtyp des werden die foreach Anweisung, wie unten beschrieben.If the var identifier is given as the local_variable_type, and no type named var is in scope, the iteration variable is said to be an implicitly typed iteration variable, and its type is taken to be the element type of the foreach statement, as specified below. Die Iterationsvariable entspricht einer schreibgeschützten lokalen Variablen mit einem Bereich, der über die eingebettete Anweisung erweitert.The iteration variable corresponds to a read-only local variable with a scope that extends over the embedded statement. Während der Ausführung einer foreach -Anweisung, die Iterationsvariable stellt das Auflistungselement für die Iteration gegenwärtig ausgeführt wird wird.During execution of a foreach statement, the iteration variable represents the collection element for which an iteration is currently being performed. Ein Fehler während der Kompilierung tritt auf, wenn die eingebettete Anweisung versucht, so ändern Sie die Iterationsvariable (per Zuweisung oder ++ und -- Operatoren) oder übergeben Sie die Iterationsvariable als einen ref oder out Parameter.A compile-time error occurs if the embedded statement attempts to modify the iteration variable (via assignment or the ++ and -- operators) or pass the iteration variable as a ref or out parameter.

Im folgenden wird aus Gründen der Übersichtlichkeit IEnumerable, IEnumerator, IEnumerable<T> und IEnumerator<T> finden Sie in die entsprechenden Typen in den Namespaces System.Collections und System.Collections.Generic.In the following, for brevity, IEnumerable, IEnumerator, IEnumerable<T> and IEnumerator<T> refer to the corresponding types in the namespaces System.Collections and System.Collections.Generic.

Die Verarbeitung während der Kompilierung einer Foreach-Anweisung zuerst bestimmt das Auflistungstyp, Enumeratortyp und Elementtyp des Ausdrucks.The compile-time processing of a foreach statement first determines the collection type, enumerator type and element type of the expression. Diese Ermittlung wird wie folgt aus:This determination proceeds as follows:

  • Wenn der Typ X von Ausdruck Arraytyp ist, dann gibt es eine implizite verweiskonvertierung von X auf die IEnumerable Schnittstelle (da System.Array implementiert diese Schnittstelle).If the type X of expression is an array type then there is an implicit reference conversion from X to the IEnumerable interface (since System.Array implements this interface). Die Auflistungstyp ist die IEnumerable -Schnittstelle, die Enumeratortyp ist die IEnumerator Schnittstelle und die Elementtyp ist der Elementtyp des der Arraytyp X.The collection type is the IEnumerable interface, the enumerator type is the IEnumerator interface and the element type is the element type of the array type X.

  • Wenn der Typ X von Ausdruck ist dynamic dann gibt es eine implizite Konvertierung von Ausdruck auf die IEnumerable Schnittstelle (implizite Dynamic Konvertierungen).If the type X of expression is dynamic then there is an implicit conversion from expression to the IEnumerable interface (Implicit dynamic conversions). Die Auflistungstyp ist die IEnumerable Schnittstelle und die Enumeratortyp ist die IEnumerator Schnittstelle.The collection type is the IEnumerable interface and the enumerator type is the IEnumerator interface. Wenn der var Bezeichner angegeben wird, als die Local_variable_type die Elementtyp ist dynamic, andernfalls ist es object.If the var identifier is given as the local_variable_type then the element type is dynamic, otherwise it is object.

  • Andernfalls bestimmt, ob der Typ X verfügt über eine entsprechende GetEnumerator Methode:Otherwise, determine whether the type X has an appropriate GetEnumerator method:

    • Führen Sie die Suche nach Membern des Typs X mit dem Bezeichner GetEnumerator und keine Typargumente.Perform member lookup on the type X with identifier GetEnumerator and no type arguments. Wenn die Membersuche keine Übereinstimmung ergibt oder eine Mehrdeutigkeit erzeugt oder erzeugt eine Übereinstimmung, die keine Methodengruppe ist, überprüfen Sie für eine enumerable-Schnittstelle, wie unten beschrieben.If the member lookup does not produce a match, or it produces an ambiguity, or produces a match that is not a method group, check for an enumerable interface as described below. Es wird empfohlen, dass eine Warnung ausgegeben werden, wenn die Suche nach Membern erzeugt alles außer einer Methodengruppe oder keine Übereinstimmung.It is recommended that a warning be issued if member lookup produces anything except a method group or no match.
    • Führen Sie die Auflösung von funktionsüberladungen mit der resultierenden Methodengruppe und einer leeren Argumentliste.Perform overload resolution using the resulting method group and an empty argument list. Wenn keine entsprechenden Methoden Auflösung von funktionsüberladungen ergibt, führt zu einer Mehrdeutigkeit und führt zu einer einzelnen bewährte Methode, aber diese Methode entweder statisch oder nicht öffentlich ist, überprüfen Sie für eine enumerable-Schnittstelle, ist wie unten beschrieben.If overload resolution results in no applicable methods, results in an ambiguity, or results in a single best method but that method is either static or not public, check for an enumerable interface as described below. Es wird empfohlen, dass eine Warnung ausgegeben werden, wenn die Auflösung von funktionsüberladungen alles mit Ausnahme von eine eindeutige öffentliche Instanzmethode oder keine anwendbaren Methoden erzeugt.It is recommended that a warning be issued if overload resolution produces anything except an unambiguous public instance method or no applicable methods.
    • Wenn der Rückgabetyp E von der GetEnumerator Methode ist keine Klasse, Struktur oder Schnittstelle-Typ, ein Fehler erzeugt wird und keine weiteren Schritte ausgeführt.If the return type E of the GetEnumerator method is not a class, struct or interface type, an error is produced and no further steps are taken.
    • Suche nach Membern erfolgt auf E mit dem Bezeichner Current und keine Typargumente.Member lookup is performed on E with the identifier Current and no type arguments. Wenn die Suche nach Membern keine Übereinstimmung erzeugt, das Ergebnis ein Fehler ist oder das Ergebnis ist nichts außer eine öffentliche Instanz-Eigenschaft, die beim Lesen zu können, ein Fehler erzeugt wird und keine weiteren Schritte ausgeführt.If the member lookup produces no match, the result is an error, or the result is anything except a public instance property that permits reading, an error is produced and no further steps are taken.
    • Suche nach Membern erfolgt auf E mit dem Bezeichner MoveNext und keine Typargumente.Member lookup is performed on E with the identifier MoveNext and no type arguments. Wenn die Suche nach Membern keine Übereinstimmung erzeugt, das Ergebnis ein Fehler ist oder das Ergebnis alles außer einer Methodengruppe ist, ein Fehler erzeugt wird und keine weiteren Schritte ausgeführt.If the member lookup produces no match, the result is an error, or the result is anything except a method group, an error is produced and no further steps are taken.
    • Überladungsauflösung erfolgt auf die Methodengruppe mit einer leeren Argumentliste.Overload resolution is performed on the method group with an empty argument list. Wenn Überladung Lösung führt keine entsprechenden Methoden, führt zu einer Mehrdeutigkeit oder Ergebnisse in einer einzelnen bewährte Methode, aber diese Methode entweder statisch oder nicht öffentlich ist oder der Rückgabetyp nicht ist bool, ein Fehler erzeugt wird und keine weiteren Schritte ausgeführt.If overload resolution results in no applicable methods, results in an ambiguity, or results in a single best method but that method is either static or not public, or its return type is not bool, an error is produced and no further steps are taken.
    • Die Auflistungstyp ist X, Enumeratortyp ist E, und die Elementtyp ist der Typ des der Current Eigenschaft.The collection type is X, the enumerator type is E, and the element type is the type of the Current property.
  • Überprüfen Sie andernfalls für eine enumerable-Schnittstelle:Otherwise, check for an enumerable interface:

    • If für alle Typen Ti für den es eine implizite Konvertierung von X zu IEnumerable<Ti>, es ist ein eindeutiger Typ T so, dass T ist nicht dynamic und für alle anderen Ti gibt es ein implizite Konvertierung von IEnumerable<T> zu IEnumerable<Ti>, und klicken Sie dann die Auflistungstyp ist die Schnittstelle IEnumerable<T>, Enumeratortyp ist die Schnittstelle IEnumerator<T>, und die Elementtyp ist T.If among all the types Ti for which there is an implicit conversion from X to IEnumerable<Ti>, there is a unique type T such that T is not dynamic and for all the other Ti there is an implicit conversion from IEnumerable<T> to IEnumerable<Ti>, then the collection type is the interface IEnumerable<T>, the enumerator type is the interface IEnumerator<T>, and the element type is T.
    • Wenn mehr als ein solcher Typ vorhanden ist, andernfalls T, klicken Sie dann ein Fehler erzeugt wird und keine weiteren Schritte ausgeführt.Otherwise, if there is more than one such type T, then an error is produced and no further steps are taken.
    • Andernfalls, wenn es eine implizite Konvertierung von X auf die System.Collections.IEnumerable -Schnittstelle, die Auflistungstyp ist diese Schnittstelle, die Enumeratortyp ist die Schnittstelle System.Collections.IEnumerator, und die Elementtyp ist object.Otherwise, if there is an implicit conversion from X to the System.Collections.IEnumerable interface, then the collection type is this interface, the enumerator type is the interface System.Collections.IEnumerator, and the element type is object.
    • Andernfalls wird ein Fehler wird ausgelöst, und keine weiteren Schritte ausgeführt.Otherwise, an error is produced and no further steps are taken.

Die oben genannten Schritte, wenn erfolgreich, eindeutig zu erzeugen einen Auflistungstyp C, Enumeratortyp E und Elementtyp T.The above steps, if successful, unambiguously produce a collection type C, enumerator type E and element type T. Eine Foreach-Anweisung der formA foreach statement of the form

foreach (V v in x) embedded_statement

Klicken Sie dann auf Erweitert:is then expanded to:

{
    E e = ((C)(x)).GetEnumerator();
    try {
        while (e.MoveNext()) {
            V v = (V)(T)e.Current;
            embedded_statement
        }
    }
    finally {
        ... // Dispose e
    }
}

Die Variable e ist nicht sichtbar bzw. zugegriffen werden kann, auf den Ausdruck x oder die eingebettete Anweisung oder jeden anderen Quellcode des Programms.The variable e is not visible to or accessible to the expression x or the embedded statement or any other source code of the program. Die Variable v in die eingebettete Anweisung schreibgeschützt ist.The variable v is read-only in the embedded statement. Wenn keine explizite Konvertierung vorhanden ist (explizite Konvertierungen) von T (der Typ des Elements), V (die Local_variable_type in der Foreach-Anweisung), ein Fehler wird ausgelöst, und es werden keine weiteren Schritte ausgeführt.If there is not an explicit conversion (Explicit conversions) from T (the element type) to V (the local_variable_type in the foreach statement), an error is produced and no further steps are taken. Wenn x hat den Wert null, System.NullReferenceException wird zur Laufzeit ausgelöst.If x has the value null, a System.NullReferenceException is thrown at run-time.

Eine Implementierung ist auf eine gegebenen Foreach-Anweisung auf andere Weise, z. B. zur Verbesserung der Leistung, implementiert zulässig, solange das Verhalten konsistent mit der Erweiterung der oben genannten ist.An implementation is permitted to implement a given foreach-statement differently, e.g. for performance reasons, as long as the behavior is consistent with the above expansion.

Die Platzierung von v innerhalb der While-Schleife ist wichtig, dass Sie wie sie eine anonyme Funktion, die im erfasst wird die Embedded_statement.The placement of v inside the while loop is important for how it is captured by any anonymous function occurring in the embedded_statement.

Zum Beispiel:For example:

int[] values = { 7, 9, 13 };
Action f = null;

foreach (var value in values)
{
    if (f == null) f = () => Console.WriteLine("First value: " + value);
}

f();

Wenn v deklariert wurde, außerhalb der While-Schleife wird für alle Iterationen und dessen Wert nach gemeinsam genutzt werden die für Schleife den endgültigen Wert wäre 13, d.h. welche der Aufruf von f druckt.If v was declared outside of the while loop, it would be shared among all iterations, and its value after the for loop would be the final value, 13, which is what the invocation of f would print. Stattdessen, da jede Iteration eine eigene Variable weist v, die von erfasst f in der ersten Iteration weiterhin den Wert enthalten soll 7, dies ist, was gedruckt werden.Instead, because each iteration has its own variable v, the one captured by f in the first iteration will continue to hold the value 7, which is what will be printed. (Hinweis: frühere Versionen von c# deklariert v außerhalb der While-Schleife.)(Note: earlier versions of C# declared v outside of the while loop.)

Der Hauptteil der Block wird schließlich anhand der folgenden Schritte erstellt:The body of the finally block is constructed according to the following steps:

  • Es ist eine implizite Konvertierung von E auf die System.IDisposable Schnittstelle ist, klicken Sie dannIf there is an implicit conversion from E to the System.IDisposable interface, then

    • Wenn E ist ein NULL-Werte wird die Klausel wird schließlich erweitert, um die semantischen Darstellung:If E is a non-nullable value type then the finally clause is expanded to the semantic equivalent of:

      finally {
          ((System.IDisposable)e).Dispose();
      }
      
    • Andernfalls die Klausel wird schließlich erweitert, um die semantischen Darstellung:Otherwise the finally clause is expanded to the semantic equivalent of:

      finally {
          if (e != null) ((System.IDisposable)e).Dispose();
      }
      

    mit der Ausnahme, dass bei E ist ein Werttyp oder ein Typparameter instanziiert, um einen Werttyp handelt, und klicken Sie dann auf die Umwandlung von e zu System.IDisposable verursacht keine Boxing auftreten.except that if E is a value type, or a type parameter instantiated to a value type, then the cast of e to System.IDisposable will not cause boxing to occur.

  • Andernfalls gilt: Wenn E einen versiegelten Typ, der zum Schluss wird die Klausel zu einem leeren Block erweitert:Otherwise, if E is a sealed type, the finally clause is expanded to an empty block:

    finally {
    }
    
  • Andernfalls, die schließlich-Klausel erweitert:Otherwise, the finally clause is expanded to:

    finally {
        System.IDisposable d = e as System.IDisposable;
        if (d != null) d.Dispose();
    }
    

    Die lokale Variable d ist nicht sichtbar bzw. Benutzercode zugegriffen werden kann.The local variable d is not visible to or accessible to any user code. Es vor allem keine Konflikte mit einer anderen Variablen, deren Bereich umfasst, die finally-block.In particular, it does not conflict with any other variable whose scope includes the finally block.

Die Reihenfolge, in der foreach durchläuft die Elemente eines Arrays, lautet wie folgt: Für eindimensionale Arrays von Elementen in aufsteigender Indexreihenfolge durchlaufen werden, beginnend mit dem Index 0 und endend mit Index Length - 1.The order in which foreach traverses the elements of an array, is as follows: For single-dimensional arrays elements are traversed in increasing index order, starting with index 0 and ending with index Length - 1. Für mehrdimensionale Arrays werden Elemente durchlaufen, sodass die Indizes von die Dimension ganz rechts erhöhte zuerst, dann weiter linken Dimension, und so weiter auf der linken Seite sind.For multi-dimensional arrays, elements are traversed such that the indices of the rightmost dimension are increased first, then the next left dimension, and so on to the left.

Das folgende Beispiel gibt jeden Wert in ein zweidimensionales Array, in der Reihenfolge der Elemente:The following example prints out each value in a two-dimensional array, in element order:

using System;

class Test
{
    static void Main() {
        double[,] values = {
            {1.2, 2.3, 3.4, 4.5},
            {5.6, 6.7, 7.8, 8.9}
        };

        foreach (double elementValue in values)
            Console.Write("{0} ", elementValue);

        Console.WriteLine();
    }
}

Die Ausgabe lautet wie folgt aus:The output produced is as follows:

1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9

Im BeispielIn the example

int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);

Der Typ des n wird davon ausgegangen werden int, den Elementtyp des numbers.the type of n is inferred to be int, the element type of numbers.

SprunganweisungenJump statements

Sprunganweisungen übertragen der Steuerung bedingungslos.Jump statements unconditionally transfer control.

jump_statement
    : break_statement
    | continue_statement
    | goto_statement
    | return_statement
    | throw_statement
    ;

Der Speicherort, der eine Jump-Anweisung überträgt die Steuerung, wird aufgerufen, die Ziel der Jump-Anweisung.The location to which a jump statement transfers control is called the target of the jump statement.

Wenn eine Jump-Anweisung innerhalb eines Blocks auftritt und das Ziel dieser Jump-Anweisung außerhalb dieses Blocks ist, der Jump-Anweisung gilt als beenden des Blocks.When a jump statement occurs within a block, and the target of that jump statement is outside that block, the jump statement is said to exit the block. Während eine sprunganweisung die Steuerung einen Block übertragen, können sie nie Steuerelement in einem Block übertragen.While a jump statement may transfer control out of a block, it can never transfer control into a block.

Sprunganweisungen Ausführung wird durch das Vorhandensein der dazwischen liegenden verkompliziert try Anweisungen.Execution of jump statements is complicated by the presence of intervening try statements. In Ermangelung eines solchen try Anweisungen, die eine Jump-Anweisung überträgt die Steuerung bedingungslos aus der Jump-Anweisung an das Ziel.In the absence of such try statements, a jump statement unconditionally transfers control from the jump statement to its target. Bei solchen dazwischen liegenden try -Anweisungen, die Ausführung ist komplexer.In the presence of such intervening try statements, execution is more complex. Wenn der Jump-Anweisung beendet, eine oder mehrere wird try Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the jump statement exits one or more try blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke aller beteiligten try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all intervening try statements have been executed.

Im BeispielIn the example

using System;

class Test
{
    static void Main() {
        while (true) {
            try {
                try {
                    Console.WriteLine("Before break");
                    break;
                }
                finally {
                    Console.WriteLine("Innermost finally block");
                }
            }
            finally {
                Console.WriteLine("Outermost finally block");
            }
        }
        Console.WriteLine("After break");
    }
}

die finally zwei zugeordneten Blöcken try -Anweisungen werden ausgeführt, bevor die Steuerung an das Ziel der Jump-Anweisung übertragen wird.the finally blocks associated with two try statements are executed before control is transferred to the target of the jump statement.

Die Ausgabe lautet wie folgt aus:The output produced is as follows:

Before break
Innermost finally block
Outermost finally block
After break

Die Break-AnweisungThe break statement

Die break -Anweisung beendet der nächsten einschließenden switch, while, do, for, oder foreach Anweisung.The break statement exits the nearest enclosing switch, while, do, for, or foreach statement.

break_statement
    : 'break' ';'
    ;

Das Ziel einer break Anweisung ist der Endpunkt der nächsten einschließenden switch, while, do, for, oder foreach Anweisung.The target of a break statement is the end point of the nearest enclosing switch, while, do, for, or foreach statement. Wenn eine break -Anweisung ist nicht eingeschlossen, indem eine switch, while, do, for, oder foreach -Anweisung ein Fehler während der Kompilierung auftritt.If a break statement is not enclosed by a switch, while, do, for, or foreach statement, a compile-time error occurs.

Wenn mehrere switch, while, do, for, oder foreach Anweisungen geschachtelt sind, eine break Aussage gilt nur für die innerste-Anweisung.When multiple switch, while, do, for, or foreach statements are nested within each other, a break statement applies only to the innermost statement. Um das Steuerelement über mehrere Verschachtelungsebenen übertragen einer goto Anweisung (Goto-Anweisung) muss verwendet werden.To transfer control across multiple nesting levels, a goto statement (The goto statement) must be used.

Ein break Anweisung kann nicht beendet eine finally Block (der Try-Anweisung).A break statement cannot exit a finally block (The try statement). Wenn eine break -Anweisung befindet sich in eine finally blockieren, das Ziel des der break -Anweisung muss innerhalb eines Abonnements sein finally blockieren; andernfalls ein Kompilierungsfehler tritt auf.When a break statement occurs within a finally block, the target of the break statement must be within the same finally block; otherwise, a compile-time error occurs.

Ein break -Anweisung wird wie folgt ausgeführt:A break statement is executed as follows:

  • Wenn die break -Anweisung beendet eine oder mehrere try Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the break statement exits one or more try blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke aller beteiligten try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all intervening try statements have been executed.
  • Die Steuerung an das Ziel der break Anweisung.Control is transferred to the target of the break statement.

Da eine break Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine break -Anweisung ist nicht erreichbar.Because a break statement unconditionally transfers control elsewhere, the end point of a break statement is never reachable.

Die Continue-AnweisungThe continue statement

Die continue Anweisung startet eine neue Iteration der nächsten einschließenden while, do, for, oder foreach Anweisung.The continue statement starts a new iteration of the nearest enclosing while, do, for, or foreach statement.

continue_statement
    : 'continue' ';'
    ;

Das Ziel einer continue -Anweisung ist der Endpunkt, der die eingebettete Anweisung der nächsten einschließenden while, do, for, oder foreach Anweisung.The target of a continue statement is the end point of the embedded statement of the nearest enclosing while, do, for, or foreach statement. Wenn eine continue -Anweisung ist nicht eingeschlossen, indem eine while, do, for, oder foreach -Anweisung ein Fehler während der Kompilierung auftritt.If a continue statement is not enclosed by a while, do, for, or foreach statement, a compile-time error occurs.

Wenn mehrere while, do, for, oder foreach Anweisungen geschachtelt sind, eine continue Aussage gilt nur für die innerste-Anweisung.When multiple while, do, for, or foreach statements are nested within each other, a continue statement applies only to the innermost statement. Um das Steuerelement über mehrere Verschachtelungsebenen übertragen einer goto Anweisung (Goto-Anweisung) muss verwendet werden.To transfer control across multiple nesting levels, a goto statement (The goto statement) must be used.

Ein continue Anweisung kann nicht beendet eine finally Block (der Try-Anweisung).A continue statement cannot exit a finally block (The try statement). Beim ein continue -Anweisung befindet sich in eine finally blockieren, das Ziel der continue -Anweisung muss innerhalb eines Abonnements sein finally blockieren; andernfalls tritt ein Fehler während der Kompilierung auf.When a continue statement occurs within a finally block, the target of the continue statement must be within the same finally block; otherwise a compile-time error occurs.

Ein continue -Anweisung wird wie folgt ausgeführt:A continue statement is executed as follows:

  • Wenn die continue -Anweisung beendet eine oder mehrere try Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the continue statement exits one or more try blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke aller beteiligten try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all intervening try statements have been executed.
  • Die Steuerung an das Ziel der continue Anweisung.Control is transferred to the target of the continue statement.

Da eine continue Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine continue -Anweisung ist nicht erreichbar.Because a continue statement unconditionally transfers control elsewhere, the end point of a continue statement is never reachable.

Die goto-AnweisungThe goto statement

Die goto -Anweisung überträgt die Steuerung an eine Anweisung, die von einer Bezeichnung markiert ist.The goto statement transfers control to a statement that is marked by a label.

goto_statement
    : 'goto' identifier ';'
    | 'goto' 'case' constant_expression ';'
    | 'goto' 'default' ';'
    ;

Das Ziel einer goto Bezeichner ist die bezeichnete Anweisung mit der angegebenen Bezeichnung.The target of a goto identifier statement is the labeled statement with the given label. Wenn eine Bezeichnung mit dem angegebenen Namen in das aktuelle Funktionselement nicht vorhanden ist, oder wenn die goto Anweisung ist nicht innerhalb des Bereichs für die Beschriftung, ein Fehler während der Kompilierung auftritt.If a label with the given name does not exist in the current function member, or if the goto statement is not within the scope of the label, a compile-time error occurs. Diese Regel ermöglicht die Verwendung von einem goto Anweisung, um das Steuerelement aus einem geschachtelten Bereich, jedoch nicht in einem geschachtelten Bereich übertragen.This rule permits the use of a goto statement to transfer control out of a nested scope, but not into a nested scope. Im BeispielIn the example

using System;

class Test
{
    static void Main(string[] args) {
        string[,] table = {
            {"Red", "Blue", "Green"},
            {"Monday", "Wednesday", "Friday"}
        };

        foreach (string str in args) {
            int row, colm;
            for (row = 0; row <= 1; ++row)
                for (colm = 0; colm <= 2; ++colm)
                    if (str == table[row,colm])
                         goto done;

            Console.WriteLine("{0} not found", str);
            continue;
    done:
            Console.WriteLine("Found {0} at [{1}][{2}]", str, row, colm);
        }
    }
}

eine goto -Anweisung verwendet, um das Steuerelement aus einem geschachtelten Bereich zu übertragen.a goto statement is used to transfer control out of a nested scope.

Das Ziel einer goto case -Anweisung ist der Anweisungsliste im unmittelbar einschließenden switch Anweisung (der Switch-Anweisung), enthält eine case Bezeichnung mit dem angegebenen konstanten Wert.The target of a goto case statement is the statement list in the immediately enclosing switch statement (The switch statement), which contains a case label with the given constant value. Wenn die goto case -Anweisung ist nicht eingeschlossen, indem eine switch -Anweisung, wenn die Constant_expression kann nicht implizit konvertiert werden (implizite Konvertierungen) auf der vorherrschende Datentyp der nächste einschließende switch -Anweisung, oder wenn der nächsten einschließenden switch Anweisung enthält keine case Bezeichnung mit dem angegebenen konstanten Wert ein Fehler während der Kompilierung auftritt.If the goto case statement is not enclosed by a switch statement, if the constant_expression is not implicitly convertible (Implicit conversions) to the governing type of the nearest enclosing switch statement, or if the nearest enclosing switch statement does not contain a case label with the given constant value, a compile-time error occurs.

Das Ziel einer goto default -Anweisung ist der Anweisungsliste im unmittelbar einschließenden switch Anweisung (der Switch-Anweisung), enthält eine default Bezeichnung.The target of a goto default statement is the statement list in the immediately enclosing switch statement (The switch statement), which contains a default label. Wenn die goto default -Anweisung ist nicht eingeschlossen, indem eine switch -Anweisung, oder, wenn der nächsten einschließenden switch Anweisung enthält keine default beschriften, tritt ein Fehler während der Kompilierung.If the goto default statement is not enclosed by a switch statement, or if the nearest enclosing switch statement does not contain a default label, a compile-time error occurs.

Ein goto Anweisung kann nicht beendet eine finally Block (der Try-Anweisung).A goto statement cannot exit a finally block (The try statement). Beim eine goto -Anweisung befindet sich in eine finally blockieren, das Ziel der goto -Anweisung muss innerhalb eines Abonnements sein finally Block, oder andernfalls ein Kompilierungsfehler tritt auf.When a goto statement occurs within a finally block, the target of the goto statement must be within the same finally block, or otherwise a compile-time error occurs.

Ein goto -Anweisung wird wie folgt ausgeführt:A goto statement is executed as follows:

  • Wenn die goto -Anweisung beendet eine oder mehrere try Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the goto statement exits one or more try blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke aller beteiligten try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all intervening try statements have been executed.
  • Die Steuerung an das Ziel der goto Anweisung.Control is transferred to the target of the goto statement.

Da eine goto Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine goto -Anweisung ist nicht erreichbar.Because a goto statement unconditionally transfers control elsewhere, the end point of a goto statement is never reachable.

Die return-AnweisungThe return statement

Die return -Anweisung übergibt die Kontrolle an den aktuellen Aufrufer der Funktion in der die return -Anweisung angezeigt wird.The return statement returns control to the current caller of the function in which the return statement appears.

return_statement
    : 'return' expression? ';'
    ;

Ein return Anweisung ohne Ausdruck kann verwendet werden, nur in ein Funktionsmember, die keinen Wert, d. h. eine Methode mit dem Ergebnistyp berechnet (Methodentext) void, set Accessor einer Eigenschaft oder Indexer der add und remove Accessoren der ein Ereignis, ein Instanzkonstruktor, einen statischen Konstruktor oder Destruktor.A return statement with no expression can be used only in a function member that does not compute a value, that is, a method with the result type (Method body) void, the set accessor of a property or indexer, the add and remove accessors of an event, an instance constructor, a static constructor, or a destructor.

Ein return -Anweisung mit einem Ausdruck kann nur verwendet werden, in ein Funktionsmember, die einen Wert, d. h. eine Methode mit einem nicht-Void-Ergebnistyp, berechnet die get Accessor einer Eigenschaft oder der Indexer oder ein benutzerdefinierter Operator.A return statement with an expression can only be used in a function member that computes a value, that is, a method with a non-void result type, the get accessor of a property or indexer, or a user-defined operator. Eine implizite Konvertierung (implizite Konvertierungen) muss vorhanden sein, von dem Typ des Ausdrucks in den Rückgabetyp des enthaltenden Elements Funktion.An implicit conversion (Implicit conversions) must exist from the type of the expression to the return type of the containing function member.

Zurückgeben, Anweisungen können auch verwendet werden, im Text der anonyme Funktionsausdrücke (anonyme Funktionsausdrücke), und daran teilnehmen, die bestimmen, welche Konvertierungen für diese Funktionen vorhanden sind.Return statements can also be used in the body of anonymous function expressions (Anonymous function expressions), and participate in determining which conversions exist for those functions.

Es ist ein Fehler während der Kompilierung für eine return -Anweisung auftreten einer finally Block (der Try-Anweisung).It is a compile-time error for a return statement to appear in a finally block (The try statement).

Ein return -Anweisung wird wie folgt ausgeführt:A return statement is executed as follows:

  • Wenn die return -Anweisung gibt einen Ausdruck, der Ausdruck wird ausgewertet, und der resultierende Wert wird durch eine implizite Konvertierung in den Rückgabetyp der enthaltenden Funktion konvertiert.If the return statement specifies an expression, the expression is evaluated and the resulting value is converted to the return type of the containing function by an implicit conversion. Das Ergebnis der Konvertierung wird der Ergebniswert, der von der Funktion generiert wurde.The result of the conversion becomes the result value produced by the function.
  • Wenn die return -Anweisung wird durch eine oder mehrere eingeschlossen try oder catch Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the return statement is enclosed by one or more try or catch blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke alle einschließenden try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all enclosing try statements have been executed.
  • Wenn die enthaltende-Funktion keine Async-Funktion ist, wird die Steuerung an den Aufrufer der enthaltenden Funktion zusammen mit dem Ergebniswert ggf. zurückgegeben.If the containing function is not an async function, control is returned to the caller of the containing function along with the result value, if any.
  • Wenn die enthaltende-Funktion eine asynchrone Funktion ist, die Steuerung wieder an den aktuellen Aufrufer und der Ergebniswert, sofern vorhanden, in der return-Aufgabe aufgezeichnet wird wie in beschrieben (Enumeratorschnittstellen).If the containing function is an async function, control is returned to the current caller, and the result value, if any, is recorded in the return task as described in (Enumerator interfaces).

Da eine return Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine return -Anweisung ist nicht erreichbar.Because a return statement unconditionally transfers control elsewhere, the end point of a return statement is never reachable.

Die Throw-AnweisungThe throw statement

Die throw Anweisung löst eine Ausnahme aus.The throw statement throws an exception.

throw_statement
    : 'throw' expression? ';'
    ;

Ein throw -Anweisung mit einem Ausdruck löst aus, der von der Auswertung des Ausdrucks erzeugte Wert.A throw statement with an expression throws the value produced by evaluating the expression. Der Ausdruck muss einen Wert des Klassentyps deuten System.Exception, eines Klassentyps, die von abgeleitet System.Exception oder von einem Typ der Type-Parameter, die System.Exception (oder eine Unterklasse davon) als effektive Basisklasse.The expression must denote a value of the class type System.Exception, of a class type that derives from System.Exception or of a type parameter type that has System.Exception (or a subclass thereof) as its effective base class. Wenn die Auswertung des Ausdrucks erzeugt null, System.NullReferenceException sondern ausgelöst.If evaluation of the expression produces null, a System.NullReferenceException is thrown instead.

Ein throw Anweisung ohne Ausdruck kann nur in verwendet werden eine catch blockieren, die in diesem Fall erneut die Anweisung wird die Ausnahme ausgelöst, die derzeit von diesem behandelt wird catch Block.A throw statement with no expression can be used only in a catch block, in which case that statement re-throws the exception that is currently being handled by that catch block.

Da eine throw Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine throw -Anweisung ist nicht erreichbar.Because a throw statement unconditionally transfers control elsewhere, the end point of a throw statement is never reachable.

Wenn eine Ausnahme ausgelöst wird, wird die Steuerung an die erste catch -Klausel in einer einschließenden try -Anweisung, die die Ausnahme behandeln kann.When an exception is thrown, control is transferred to the first catch clause in an enclosing try statement that can handle the exception. Der Prozess, der ab dem Zeitpunkt der ausgelösten Ausnahme zum Zeitpunkt des Übertragens der Steuerung an einen geeigneten Ausnahmehandler stattfindet, wird als bezeichnet ausnahmeweitergabe.The process that takes place from the point of the exception being thrown to the point of transferring control to a suitable exception handler is known as exception propagation. Weitergabe einer Ausnahme besteht aus der Auswertung wiederholt die folgenden Schritte aus, bis eine catch -Klausel, die die Ausnahme entspricht gefunden wird.Propagation of an exception consists of repeatedly evaluating the following steps until a catch clause that matches the exception is found. In dieser Beschreibung die Punkt auslösen beträgt anfänglich der Speicherort, an dem die Ausnahme wird ausgelöst.In this description, the throw point is initially the location at which the exception is thrown.

  • In das aktuelle Funktionselement jede try -Anweisung, die den Throw einschließt, wird untersucht.In the current function member, each try statement that encloses the throw point is examined. Für jede Anweisung S, beginnend mit der innersten try -Anweisung und bis hin zu den äußersten try -Anweisung werden ausgewertet, die folgenden Schritte aus:For each statement S, starting with the innermost try statement and ending with the outermost try statement, the following steps are evaluated:

    • Wenn die try -Block S umschließt der auslösepunkt und S eine oder mehrere catch -Klauseln, die catch -Klauseln nacheinander überprüft werden, in der Reihenfolge ihres Auftretens einen geeigneten Handler für die Ausnahme, gemäß den Regeln, die im angegebenen gefunden Abschnitt der Try-Anweisung.If the try block of S encloses the throw point and if S has one or more catch clauses, the catch clauses are examined in order of appearance to locate a suitable handler for the exception, according to the rules specified in Section The try statement. Wenn kein übereinstimmendes catch Klausel befindet, die ausnahmeweitergabe erfolgt durch Übergabe der Steuerung an den Block, catch Klausel.If a matching catch clause is located, the exception propagation is completed by transferring control to the block of that catch clause.

    • Andernfalls gilt: Wenn die try Block oder ein catch -Block S umschließt der auslösepunkt und, wenn S verfügt über eine finally auf Steuerelement-Block übertragen wird die finally Block.Otherwise, if the try block or a catch block of S encloses the throw point and if S has a finally block, control is transferred to the finally block. Wenn die finally Block eine weitere Ausnahme auslöst, die Verarbeitung der aktuellen Ausnahme beendet.If the finally block throws another exception, processing of the current exception is terminated. Wenn die Steuerung über den Endpunkt erreicht, andernfalls die finally Block Verarbeitung der aktuellen Ausnahme wird fortgesetzt.Otherwise, when control reaches the end point of the finally block, processing of the current exception is continued.

  • Wenn ein Ausnahmehandler in den aktuellen Funktionsaufruf nicht gefunden wurde, der Funktionsaufruf wird beendet und eine der folgenden Bedingungen zutrifft:If an exception handler was not located in the current function invocation, the function invocation is terminated, and one of the following occurs:

    • Wenn die aktuelle Funktion nicht asynchronen ist, werden die oben genannten Schritte wiederholt für den Aufrufer der Funktion mit einer Throw-Punkt für die Anweisung, die aus der das Funktionselement aufgerufen wurde.If the current function is non-async, the steps above are repeated for the caller of the function with a throw point corresponding to the statement from which the function member was invoked.

    • Ist die aktuelle Funktion Async "und" Aufgabe zurückgibt, wird die Ausnahme in der Task zurückgeben, die in einem fehlerhaften oder abgebrochenen Zustand versetzt wird, wie in beschrieben aufgezeichnet Enumeratorschnittstellen.If the current function is async and task-returning, the exception is recorded in the return task, which is put into a faulted or cancelled state as described in Enumerator interfaces.

    • Wenn die aktuelle Funktion Async "und" void "zurückgebende ist, benachrichtigt der Synchronisierungskontext des aktuellen Threads wie in beschrieben Enumerable-Schnittstellen.If the current function is async and void-returning, the synchronization context of the current thread is notified as described in Enumerable interfaces.

  • Wenn die ausnahmeverarbeitung alle Member für Funktionsaufrufe im aktuellen Thread beendet wird, ist, der angibt, dass der Thread kein Handler für die Ausnahme, hat der Thread selbst beendet.If the exception processing terminates all function member invocations in the current thread, indicating that the thread has no handler for the exception, then the thread is itself terminated. Die Auswirkungen des Abbruchs ist implementierungsdefiniert.The impact of such termination is implementation-defined.

Der Try-AnweisungThe try statement

Die try Anweisung bietet einen Mechanismus zum Abfangen von Ausnahmen, die während der Ausführung eines Blocks auftreten.The try statement provides a mechanism for catching exceptions that occur during execution of a block. Darüber hinaus die try Anweisung bietet die Möglichkeit, einen Codeblock angeben, die immer ausgeführt wird, wenn das Steuerelement verlässt die try Anweisung.Furthermore, the try statement provides the ability to specify a block of code that is always executed when control leaves the try statement.

try_statement
    : 'try' block catch_clause+
    | 'try' block finally_clause
    | 'try' block catch_clause+ finally_clause
    ;

catch_clause
    : 'catch' exception_specifier? exception_filter?  block
    ;

exception_specifier
    : '(' type identifier? ')'
    ;

exception_filter
    : 'when' '(' expression ')'
    ;

finally_clause
    : 'finally' block
    ;

Es gibt drei mögliche Formen von try Anweisungen:There are three possible forms of try statements:

  • Ein try -Block gefolgt von einer oder mehreren catch Blöcke.A try block followed by one or more catch blocks.
  • Ein try -Block gefolgt von einem finally Block.A try block followed by a finally block.
  • Ein try -Block gefolgt von einer oder mehreren catch Blöcke gefolgt von einem finally Block.A try block followed by one or more catch blocks followed by a finally block.

Wenn eine catch -Klausel gibt ein Exception_specifier, aufweisen muss System.Exception, ein Typ, der von abgeleitet ist System.Exception oder einen Typ-Parametertyp, die System.Exception (oder eine Unterklasse davon) als der effektive Basis-Klasse.When a catch clause specifies an exception_specifier, the type must be System.Exception, a type that derives from System.Exception or a type parameter type that has System.Exception (or a subclass thereof) as its effective base class.

Wenn eine catch -Klausel gibt sowohl eine Exception_specifier mit eine Bezeichner, eine Ausnahmevariable mit dem angegebenen Namen und Typ deklariert wird.When a catch clause specifies both an exception_specifier with an identifier, an exception variable of the given name and type is declared. Die Ausnahmevariable entspricht einer lokalen Variablen mit einem Bereich, der über erweitert die catch Klausel.The exception variable corresponds to a local variable with a scope that extends over the catch clause. Während der Ausführung der Exception_filter und Block, die Ausnahmevariable stellt die Ausnahme, die gerade verarbeitet wird.During execution of the exception_filter and block, the exception variable represents the exception currently being handled. Für Zwecke der definitive Zuweisungen zu überprüfen gilt die Ausnahmevariable im gesamten Bereich definitiv zugewiesen.For purposes of definite assignment checking, the exception variable is considered definitely assigned in its entire scope.

Es sei denn, eine catch -Klausel enthält einen Variablennamen der Ausnahme, es ist nicht möglich, auf das Ausnahmeobjekt im Filter und catch Block.Unless a catch clause includes an exception variable name, it is impossible to access the exception object in the filter and catch block.

Ein catch -Klausel nicht angegeben ist, die eine Exception_specifier wird aufgerufen, eine allgemeine catch Klausel.A catch clause that does not specify an exception_specifier is called a general catch clause.

Einige Programmiersprachen unterstützen möglicherweise Ausnahmen, die nicht darstellbar sind, wie ein Objekt abgeleitet System.Exception, obwohl solche Ausnahmen niemals von c#-Code generiert werden können.Some programming languages may support exceptions that are not representable as an object derived from System.Exception, although such exceptions could never be generated by C# code. Eine allgemeine catch -Klausel kann verwendet werden, um solche Ausnahmen abzufangen.A general catch clause may be used to catch such exceptions. Daher eine allgemeine catch -Klausel ist semantisch, die den Typ angibt, System.Exception, die erste auch aus anderen Sprachen Abfangen von Ausnahmen kann.Thus, a general catch clause is semantically different from one that specifies the type System.Exception, in that the former may also catch exceptions from other languages.

Um einen Handler für eine Ausnahme aus, suchen catch -Klauseln nacheinander überprüft werden, in der lexikalischen Reihenfolge.In order to locate a handler for an exception, catch clauses are examined in lexical order. Wenn eine catch -Klausel gibt an, ein Typ, aber keine Ausnahmefilter, es ist ein Fehler während der Kompilierung für eine höhere catch Klausel in der gleichen try -Anweisung geben Sie einen Typ, die entspricht, oder wird abgeleitet, die eingeben.If a catch clause specifies a type but no exception filter, it is a compile-time error for a later catch clause in the same try statement to specify a type that is the same as, or is derived from, that type. Wenn eine catch -Klausel gibt an, kein Typ und kein Filter, er muss die letzte catch -Klausel, die für die try Anweisung.If a catch clause specifies no type and no filter, it must be the last catch clause for that try statement.

Innerhalb einer catch Block eine throw Anweisung (die Throw-Anweisung) kein Ausdruck kann verwendet werden, um die Ausnahme erneut auszulösen, die von abgefangen wurde die catch Block.Within a catch block, a throw statement (The throw statement) with no expression can be used to re-throw the exception that was caught by the catch block. Zuweisungen für eine Ausnahmevariable ändern nicht die Ausnahme, die erneut ausgelöst wird.Assignments to an exception variable do not alter the exception that is re-thrown.

Im BeispielIn the example

using System;

class Test
{
    static void F() {
        try {
            G();
        }
        catch (Exception e) {
            Console.WriteLine("Exception in F: " + e.Message);
            e = new Exception("F");
            throw;                // re-throw
        }
    }

    static void G() {
        throw new Exception("G");
    }

    static void Main() {
        try {
            F();
        }
        catch (Exception e) {
            Console.WriteLine("Exception in Main: " + e.Message);
        }
    }
}

die Methode F wird eine Ausnahme abgefangen, Diagnoseinformationen an die Konsole schreibt, ändert die Ausnahmevariable und löst die Ausnahme erneut aus.the method F catches an exception, writes some diagnostic information to the console, alters the exception variable, and re-throws the exception. Die Ausnahme, die erneut ausgelöst wird ist die ursprüngliche Ausnahme, ist die Ausgabe:The exception that is re-thrown is the original exception, so the output produced is:

Exception in F: G
Exception in Main: G

Wenn die erste Catch-Block ausgelöst hatte e anstatt erneut die aktuelle Ausnahme ausgelöst, würde die Ausgabe wie folgt lauten:If the first catch block had thrown e instead of rethrowing the current exception, the output produced would be as follows:

Exception in F: G
Exception in Main: F

Es ist ein Fehler während der Kompilierung für eine break, continue, oder goto Anweisung, um das Übergeben der Steuerung aus einer finally Block.It is a compile-time error for a break, continue, or goto statement to transfer control out of a finally block. Wenn eine break, continue, oder goto -Anweisung befindet sich eine finally Block, der das Ziel der Anweisung muss im selben finally Block oder andernfalls ein Kompilierungsfehler tritt auf.When a break, continue, or goto statement occurs in a finally block, the target of the statement must be within the same finally block, or otherwise a compile-time error occurs.

Es ist ein Fehler während der Kompilierung für eine return -Anweisung auftreten, in eine finally Block.It is a compile-time error for a return statement to occur in a finally block.

Ein try -Anweisung wird wie folgt ausgeführt:A try statement is executed as follows:

  • Die Steuerung an die try Block.Control is transferred to the try block.

  • Wenn und die Steuerung über den Endpunkt erreicht die try blockieren:When and if control reaches the end point of the try block:

    • Wenn die try Anweisung verfügt über eine finally Block, der finally Block wird ausgeführt.If the try statement has a finally block, the finally block is executed.
    • Die Steuerung an den Endpunkt der try Anweisung.Control is transferred to the end point of the try statement.
  • Wenn eine Ausnahme, um weitergegeben wird die try Anweisung während der Ausführung der try blockieren:If an exception is propagated to the try statement during execution of the try block:

    • Die catch -Klauseln, sofern vorhanden, werden in der Reihenfolge ihres Auftretens einen geeigneten Handler für die Ausnahme gefunden überprüft.The catch clauses, if any, are examined in order of appearance to locate a suitable handler for the exception. Wenn eine catch -Klausel kein Typ angegeben ist, oder gibt an, der Typ der Ausnahme oder ein Basistyp des Ausnahmetyps:If a catch clause does not specify a type, or specifies the exception type or a base type of the exception type:
      • Wenn die catch -Klausel deklariert eine Ausnahmevariable, die Ausnahmevariable das Ausnahmeobjekt zugewiesen wird.If the catch clause declares an exception variable, the exception object is assigned to the exception variable.
      • Wenn die catch -Klausel deklariert einen Ausnahmefilter, der Filter ausgewertet wird.If the catch clause declares an exception filter, the filter is evaluated. Ergibt die Auswertung falsedie Catch-Klausel ist keine Übereinstimmung und die Suche wird fortgesetzt, bis alle nachfolgenden catch Klauseln für einen geeigneten Handler.If it evaluates to false, the catch clause is not a match, and the search continues through any subsequent catch clauses for a suitable handler.
      • Andernfalls die catch Klausel wird als Übereinstimmung angesehen, und die Steuerung an den entsprechenden catch Block.Otherwise, the catch clause is considered a match, and control is transferred to the matching catch block.
      • Wenn und die Steuerung über den Endpunkt erreicht die catch blockieren:When and if control reaches the end point of the catch block:
        • Wenn die try Anweisung verfügt über eine finally Block, der finally Block wird ausgeführt.If the try statement has a finally block, the finally block is executed.
        • Die Steuerung an den Endpunkt der try Anweisung.Control is transferred to the end point of the try statement.
      • Wenn eine Ausnahme, um weitergegeben wird die try Anweisung während der Ausführung der catch blockieren:If an exception is propagated to the try statement during execution of the catch block:
        • Wenn die try Anweisung verfügt über eine finally Block, der finally Block wird ausgeführt.If the try statement has a finally block, the finally block is executed.
        • Die Ausnahme wird an der nächsten einschließenden weitergegeben try Anweisung.The exception is propagated to the next enclosing try statement.
    • Wenn die try Anweisung hat keine catch Klauseln oder wenn keine catch Klausel entspricht, der die Ausnahme:If the try statement has no catch clauses or if no catch clause matches the exception:
      • Wenn die try Anweisung verfügt über eine finally Block, der finally Block wird ausgeführt.If the try statement has a finally block, the finally block is executed.
      • Die Ausnahme wird an der nächsten einschließenden weitergegeben try Anweisung.The exception is propagated to the next enclosing try statement.

Die Anweisungen des eine finally Block werden immer ausgeführt, wenn das Steuerelement verlässt eine try Anweisung.The statements of a finally block are always executed when control leaves a try statement. Dies ist "true" gibt an, ob die Steuerelement-Übertragung infolge einer normalen Ausführung, die als Ergebnis der Ausführung erfolgt eine break, continue, goto, oder return -Anweisung oder als Ergebnis eine Ausnahme von der try -Anweisung.This is true whether the control transfer occurs as a result of normal execution, as a result of executing a break, continue, goto, or return statement, or as a result of propagating an exception out of the try statement.

Wenn eine Ausnahme, während der Ausführung ausgelöst wird einer finally blockieren, und nicht abgefangen innerhalb desselben finally-Block, der die Ausnahme an der nächsten einschließenden weitergegeben wird try Anweisung.If an exception is thrown during execution of a finally block, and is not caught within the same finally block, the exception is propagated to the next enclosing try statement. Wenn eine andere Ausnahme war gerade weitergegeben wird, geht diese Ausnahme verloren.If another exception was in the process of being propagated, that exception is lost. Erläutert der Prozess der Weitergabe einer Ausnahme in der Beschreibung der weiteren der throw Anweisung (die Throw-Anweisung).The process of propagating an exception is discussed further in the description of the throw statement (The throw statement).

Die try -Block eine try Anweisung erreichbar ist. wenn die try -Anweisung erreichbar ist.The try block of a try statement is reachable if the try statement is reachable.

Ein catch -Block eine try Anweisung erreichbar ist. wenn die try -Anweisung erreichbar ist.A catch block of a try statement is reachable if the try statement is reachable.

Die finally -Block eine try Anweisung erreichbar ist. wenn die try -Anweisung erreichbar ist.The finally block of a try statement is reachable if the try statement is reachable.

Der Endpunkt, der eine try -Anweisung ist erreichbar, wenn die beiden folgenden Bedingungen erfüllt sind:The end point of a try statement is reachable if both of the following are true:

  • Der Endpunkt des der try Block erreichbar ist oder das Ende der mindestens eine catch Block erreichbar ist.The end point of the try block is reachable or the end point of at least one catch block is reachable.
  • Wenn eine finally Block vorhanden ist, den Endpunkt der finally Block erreichbar ist.If a finally block is present, the end point of the finally block is reachable.

Die Anweisungen checked und uncheckedThe checked and unchecked statements

Die checked und unchecked Anweisungen werden verwendet, um zu steuern die Kontext der überlaufprüfung für arithmetische Operationen für ganzzahlige Typen und Konvertierungen.The checked and unchecked statements are used to control the overflow checking context for integral-type arithmetic operations and conversions.

checked_statement
    : 'checked' block
    ;

unchecked_statement
    : 'unchecked' block
    ;

Die checked Anweisung bewirkt, dass alle Ausdrücke in der Block in einem überprüften Kontext ausgewertet werden und die unchecked Anweisung bewirkt, dass alle Ausdrücke in der Block in ausgewertet werden ein nicht geprüften Kontext.The checked statement causes all expressions in the block to be evaluated in a checked context, and the unchecked statement causes all expressions in the block to be evaluated in an unchecked context.

Die checked und unchecked -Anweisungen sind genaue Entsprechung der checked und unchecked Operatoren (checked und unchecked Operatoren), außer dass sie Blöcke anstelle von Ausdrücken ausgeführt werden .The checked and unchecked statements are precisely equivalent to the checked and unchecked operators (The checked and unchecked operators), except that they operate on blocks instead of expressions.

Die Lock-AnweisungThe lock statement

Die lock -Anweisung ruft die Sperre für gegenseitigen Ausschluss für ein bestimmtes Objekt, führt eine Anweisung aus und gibt dann die Sperre frei.The lock statement obtains the mutual-exclusion lock for a given object, executes a statement, and then releases the lock.

lock_statement
    : 'lock' '(' expression ')' embedded_statement
    ;

Der Ausdruck eine lock Anweisung muss einen Wert eines Typs, die bekanntermaßen kennzeichnen einer Reference_type.The expression of a lock statement must denote a value of a type known to be a reference_type. Kein implizites Boxing-Konvertierung (Boxingkonvertierungen) erfolgt einmal für den Ausdruck, der eine lock -Anweisung, und daher ist ein Fehler während der Kompilierung für den Ausdruck zur Bezeichnung eines Werts von einer Value_type.No implicit boxing conversion (Boxing conversions) is ever performed for the expression of a lock statement, and thus it is a compile-time error for the expression to denote a value of a value_type.

Ein lock -Anweisung der FormA lock statement of the form

lock (x) ...

wo x ist ein Ausdruck, der eine Reference_type, entspricht exakt demwhere x is an expression of a reference_type, is precisely equivalent to

bool __lockWasTaken = false;
try {
    System.Threading.Monitor.Enter(x, ref __lockWasTaken);
    ...
}
finally {
    if (__lockWasTaken) System.Threading.Monitor.Exit(x);
}

außer dass x nur einmal überprüft wird.except that x is only evaluated once.

Während eine Sperre für gegenseitigen Ausschluss gehalten wird, kann Ausführung von Code in der gleichen Ausführungsthread auch zu erhalten und die Sperre freigibt.While a mutual-exclusion lock is held, code executing in the same execution thread can also obtain and release the lock. Allerdings wird die Ausführung von Code in anderen Threads blockiert, die Sperre abrufen, bis die Sperre aufgehoben wird.However, code executing in other threads is blocked from obtaining the lock until the lock is released.

Sperren System.Type Objekte zum Synchronisieren des Zugriffs auf statische Daten wird nicht empfohlen.Locking System.Type objects in order to synchronize access to static data is not recommended. Anderer Code kann auf dem gleichen Typ, sperren, was zu Deadlocks führen kann.Other code might lock on the same type, which can result in deadlock. Ein besserer Ansatz ist, den Zugriff auf statische Daten zu synchronisieren, indem Sie ein privates statisches Objekt zu sperren.A better approach is to synchronize access to static data by locking a private static object. Zum Beispiel:For example:

class Cache
{
    private static readonly object synchronizationObject = new object();

    public static void Add(object x) {
        lock (Cache.synchronizationObject) {
            ...
        }
    }

    public static void Remove(object x) {
        lock (Cache.synchronizationObject) {
            ...
        }
    }
}

Die using-AnweisungThe using statement

Die using -Anweisung ruft eine oder mehrere Ressourcen, führt eine Anweisung aus und klicken Sie dann die Ressource frei.The using statement obtains one or more resources, executes a statement, and then disposes of the resource.

using_statement
    : 'using' '(' resource_acquisition ')' embedded_statement
    ;

resource_acquisition
    : local_variable_declaration
    | expression
    ;

Ein Ressource ist eine Klasse oder Struktur, die implementiert System.IDisposable, einschließlich eine einzelne parameterlose Methode, die mit dem Namen Dispose.A resource is a class or struct that implements System.IDisposable, which includes a single parameterless method named Dispose. Erreichen von Code, der eine Ressource verwendet Dispose um anzugeben, dass die Ressource nicht mehr benötigt wird.Code that is using a resource can call Dispose to indicate that the resource is no longer needed. Wenn Dispose nicht aufgerufen wird, wird automatische Löschung letztendlich als Folge der Garbagecollection durchgeführt.If Dispose is not called, then automatic disposal eventually occurs as a consequence of garbage collection.

Wenn die Form der Resource_acquisition ist Local_variable_declaration der Typ des der Local_variable_declaration muss dynamic oder einen Typ der implizit in konvertiert werden kann System.IDisposable.If the form of resource_acquisition is local_variable_declaration then the type of the local_variable_declaration must be either dynamic or a type that can be implicitly converted to System.IDisposable. Wenn die Form der Resource_acquisition ist Ausdruck dieser Ausdruck muss implizit in sein System.IDisposable.If the form of resource_acquisition is expression then this expression must be implicitly convertible to System.IDisposable.

Lokale Variablen, die in einem Resource_acquisition sind schreibgeschützt und muss einen Initialisierer enthalten.Local variables declared in a resource_acquisition are read-only, and must include an initializer. Ein Fehler während der Kompilierung tritt auf, wenn die eingebettete Anweisung versucht, diese lokalen Variablen zu ändern (per Zuweisung oder ++ und -- Operatoren), nehmen sie die Adresse, oder übergeben Sie sie als ref oder out Parameter.A compile-time error occurs if the embedded statement attempts to modify these local variables (via assignment or the ++ and -- operators) , take the address of them, or pass them as ref or out parameters.

Ein using -Anweisung übersetzt in drei Teile: Abruf, Verwendung und Freigabe.A using statement is translated into three parts: acquisition, usage, and disposal. Bei Verwendung der Ressource steht implizit in einen try -Anweisung mit einer finally Klausel.Usage of the resource is implicitly enclosed in a try statement that includes a finally clause. Dies finally Klausel gibt die Ressource frei.This finally clause disposes of the resource. Wenn eine null Ressource wird abgerufen, dann kein Aufruf von Dispose vorgenommen wird, und es wird keine Ausnahme ausgelöst.If a null resource is acquired, then no call to Dispose is made, and no exception is thrown. Wenn die Ressource vom Typ dynamic wird dynamisch durch eine implizite Konvertierung für die dynamische Konvertierung (implizite dynamische Konvertierungen) zu IDisposable während der Übernahme, um sicherzustellen, dass die Konvertierung ist vor der Nutzung und die Freigabe erfolgreich.If the resource is of type dynamic it is dynamically converted through an implicit dynamic conversion (Implicit dynamic conversions) to IDisposable during acquisition in order to ensure that the conversion is successful before the usage and disposal.

Ein using -Anweisung der FormA using statement of the form

using (ResourceType resource = expression) statement

entspricht einem der drei möglichen Erweiterungen.corresponds to one of three possible expansions. Wenn ResourceType ist ein Typ NULL-Werte, die Erweiterung istWhen ResourceType is a non-nullable value type, the expansion is

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        ((IDisposable)resource).Dispose();
    }
}

Andernfalls gilt bei ResourceType ist ein Werttyp oder ein Verweistyp als dynamic, ist die ErweiterungOtherwise, when ResourceType is a nullable value type or a reference type other than dynamic, the expansion is

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        if (resource != null) ((IDisposable)resource).Dispose();
    }
}

Andernfalls gilt bei ResourceType ist dynamic, ist die ErweiterungOtherwise, when ResourceType is dynamic, the expansion is

{
    ResourceType resource = expression;
    IDisposable d = (IDisposable)resource;
    try {
        statement;
    }
    finally {
        if (d != null) d.Dispose();
    }
}

In beiden Erweiterung der resource Variable ist schreibgeschützt und in die eingebettete Anweisung, und die d Variable ist nicht sichtbar und kann nicht zugegriffen werden, in an, die eingebettete Anweisung.In either expansion, the resource variable is read-only in the embedded statement, and the d variable is inaccessible in, and invisible to, the embedded statement.

Eine Implementierung ist auf eine bestimmte using-Anweisung auf andere Weise, z. B. zur Verbesserung der Leistung, implementiert zulässig, solange das Verhalten aufgrund der oben genannten steigenden konsistent ist.An implementation is permitted to implement a given using-statement differently, e.g. for performance reasons, as long as the behavior is consistent with the above expansion.

Ein using -Anweisung der FormA using statement of the form

using (expression) statement

verfügt über die gleichen drei möglichen Erweiterungen.has the same three possible expansions. In diesem Fall ResourceType ist implizit der Kompilierzeit-Typ, der die expression, sofern vorhanden.In this case ResourceType is implicitly the compile-time type of the expression, if it has one. Andernfalls die Schnittstelle IDisposable selbst dient als die ResourceType.Otherwise the interface IDisposable itself is used as the ResourceType. Die resource Variable ist nicht sichtbar und kann nicht zugegriffen werden, in an, die eingebettete Anweisung.The resource variable is inaccessible in, and invisible to, the embedded statement.

Wenn eine Resource_acquisition nimmt die Form einer Local_variable_declaration, es ist möglich, mehrere Ressourcen eines bestimmten Typs abrufen.When a resource_acquisition takes the form of a local_variable_declaration, it is possible to acquire multiple resources of a given type. Ein using -Anweisung der FormA using statement of the form

using (ResourceType r1 = e1, r2 = e2, ..., rN = eN) statement

genau entspricht einer Sequenz von geschachtelt using Anweisungen:is precisely equivalent to a sequence of nested using statements:

using (ResourceType r1 = e1)
    using (ResourceType r2 = e2)
        ...
            using (ResourceType rN = eN)
                statement

Das folgende Beispiel erstellt eine Datei namens log.txt und zwei Textzeilen in die Datei geschrieben.The example below creates a file named log.txt and writes two lines of text to the file. Im Beispiel wird dann der gleichen Datei zum Lesen geöffnet und die enthaltenen Textzeilen in der Konsole kopiert.The example then opens that same file for reading and copies the contained lines of text to the console.

using System;
using System.IO;

class Test
{
    static void Main() {
        using (TextWriter w = File.CreateText("log.txt")) {
            w.WriteLine("This is line one");
            w.WriteLine("This is line two");
        }

        using (TextReader r = File.OpenText("log.txt")) {
            string s;
            while ((s = r.ReadLine()) != null) {
                Console.WriteLine(s);
            }

        }
    }
}

Da die TextWriter und TextReader -Klassen implementieren die IDisposable -Schnittstelle, im Beispiel können using stellen Sie sicher, dass die zugrunde liegende Datei ordnungsgemäß geschlossen wird nach dem Schreiben oder Lesen Sie die Operations-Anweisungen.Since the TextWriter and TextReader classes implement the IDisposable interface, the example can use using statements to ensure that the underlying file is properly closed following the write or read operations.

Die Yield-AnweisungThe yield statement

Die yield Anweisung wird in einem Iteratorblock verwendet (Blöcke) ergibt einen Wert auf das Enumeratorobjekt (Enumeratorobjekte) oder ein aufzählbares Objekt (aufzählbare Objekte) ein Iterator oder das Ende der Iteration zu signalisieren.The yield statement is used in an iterator block (Blocks) to yield a value to the enumerator object (Enumerator objects) or enumerable object (Enumerable objects) of an iterator or to signal the end of the iteration.

yield_statement
    : 'yield' 'return' expression ';'
    | 'yield' 'break' ';'
    ;

yield ist kein reserviertes Wort. Es hat eine besondere Bedeutung, die erst bei der unmittelbar vor einem return oder break Schlüsselwort.yield is not a reserved word; it has special meaning only when used immediately before a return or break keyword. In anderen Kontexten yield als Bezeichner verwendet werden können.In other contexts, yield can be used as an identifier.

Es gibt mehrere Einschränkungen dazu, wo ein yield Anweisung angezeigt werden kann, wie im folgenden beschrieben.There are several restrictions on where a yield statement can appear, as described in the following.

  • Es ist ein Fehler während der Kompilierung für eine yield -Anweisung (entweder Form) außerhalb angezeigt werden. eine Method_body, Operator_body oder Accessor_bodyIt is a compile-time error for a yield statement (of either form) to appear outside a method_body, operator_body or accessor_body
  • Es ist ein Fehler während der Kompilierung für eine yield -Anweisung (entweder Form) innerhalb einer anonymen Funktion angezeigt werden.It is a compile-time error for a yield statement (of either form) to appear inside an anonymous function.
  • Es ist ein Fehler während der Kompilierung für eine yield -Anweisung (entweder Form) angezeigt werden die finally -Klausel einer try Anweisung.It is a compile-time error for a yield statement (of either form) to appear in the finally clause of a try statement.
  • Es ist ein Fehler während der Kompilierung für eine yield return Anweisung in eine beliebige Stelle angezeigt werden eine try -Anweisung, die enthält catch Klauseln.It is a compile-time error for a yield return statement to appear anywhere in a try statement that contains any catch clauses.

Das folgende Beispiel zeigt einige gültigen und ungültigen Verwendungen von yield Anweisungen.The following example shows some valid and invalid uses of yield statements.

delegate IEnumerable<int> D();

IEnumerator<int> GetEnumerator() {
    try {
        yield return 1;        // Ok
        yield break;           // Ok
    }
    finally {
        yield return 2;        // Error, yield in finally
        yield break;           // Error, yield in finally
    }

    try {
        yield return 3;        // Error, yield return in try...catch
        yield break;           // Ok
    }
    catch {
        yield return 4;        // Error, yield return in try...catch
        yield break;           // Ok
    }

    D d = delegate { 
        yield return 5;        // Error, yield in an anonymous function
    }; 
}

int MyMethod() {
    yield return 1;            // Error, wrong return type for an iterator block
}

Eine implizite Konvertierung (implizite Konvertierungen) muss vorhanden sein, von dem Typ des Ausdrucks in der yield return Anweisung, um den Typ "yield" (Yield-Typ) des Iterators.An implicit conversion (Implicit conversions) must exist from the type of the expression in the yield return statement to the yield type (Yield type) of the iterator.

Ein yield return -Anweisung wird wie folgt ausgeführt:A yield return statement is executed as follows:

  • Die in der Anweisung angegebene Ausdruck wird ausgewertet, implizit in den Typ "yield" konvertiert und zugewiesen der Current Eigenschaft des Enumeratorobjekts.The expression given in the statement is evaluated, implicitly converted to the yield type, and assigned to the Current property of the enumerator object.
  • Die Ausführung des Iteratorblocks wird angehalten.Execution of the iterator block is suspended. Wenn die yield return -Anweisung ist in einem oder mehreren try blockiert wird, zugeordneten finally Blöcke werden zu diesem Zeitpunkt nicht ausgeführt.If the yield return statement is within one or more try blocks, the associated finally blocks are not executed at this time.
  • Die MoveNext gibt die Methode des Enumeratorobjekts true an den Aufrufer, der angibt, dass das Enumeratorobjekt erfolgreich auf das nächste Element gesetzt wurde.The MoveNext method of the enumerator object returns true to its caller, indicating that the enumerator object successfully advanced to the next item.

Der nächste Aufruf auf des Enumeratorobjekts MoveNext -Methode setzt die Ausführung des Iteratorblocks aus, in dem es zuletzt angehalten wurde.The next call to the enumerator object's MoveNext method resumes execution of the iterator block from where it was last suspended.

Ein yield break -Anweisung wird wie folgt ausgeführt:A yield break statement is executed as follows:

  • Wenn die yield break -Anweisung wird durch eine oder mehrere eingeschlossen try Blöcke mit verknüpften finally Blöcken Steuerelement anfänglich auf übertragen wird die finally Block des innersten try Anweisung.If the yield break statement is enclosed by one or more try blocks with associated finally blocks, control is initially transferred to the finally block of the innermost try statement. Wenn und die Steuerung über den Endpunkt erreicht eine finally auf Steuerelement-Block übertragen wird die finally Block der nächsten einschließenden try Anweisung.When and if control reaches the end point of a finally block, control is transferred to the finally block of the next enclosing try statement. Dieser Prozess wird wiederholt, bis die finally Blöcke alle einschließenden try Anweisungen ausgeführt wurden.This process is repeated until the finally blocks of all enclosing try statements have been executed.
  • Steuerelement wird an den Aufrufer des Iteratorblocks zurückgegeben.Control is returned to the caller of the iterator block. Dies ist entweder der MoveNext Methode oder Dispose Methode des Enumeratorobjekts.This is either the MoveNext method or Dispose method of the enumerator object.

Da eine yield break Anweisung bedingungslos überträgt die Steuerung an anderen Positionen wird der Endpunkt, der eine yield break -Anweisung ist nicht erreichbar.Because a yield break statement unconditionally transfers control elsewhere, the end point of a yield break statement is never reachable.