Instructions (Guide de programmation C#)Statements (C# Programming Guide)

Les actions qu’un programme effectue sont exprimées dans les instructions.The actions that a program takes are expressed in statements. Les actions courantes incluent la déclaration de variables, l’assignation de valeurs, l’appel de méthodes, l’exécution de boucles dans les collections et la création de branches sur des blocs de code, selon une condition donnée.Common actions include declaring variables, assigning values, calling methods, looping through collections, and branching to one or another block of code, depending on a given condition. L’ordre dans lequel les instructions sont exécutées dans un programme est appelé le flux de contrôle ou le flux d’exécution.The order in which statements are executed in a program is called the flow of control or flow of execution. Le flux de contrôle peut varier chaque fois qu’un programme est exécuté, selon la manière dont le programme réagit à l’entrée qu’il reçoit au moment de l’exécution.The flow of control may vary every time that a program is run, depending on how the program reacts to input that it receives at run time.

Une instruction peut comporter une seule ligne de code terminée par un point-virgule ou une série d’instructions d’une ligne dans un bloc.A statement can consist of a single line of code that ends in a semicolon, or a series of single-line statements in a block. Un bloc d’instructions est placé entre des accolades ({}) et peut contenir des blocs imbriqués.A statement block is enclosed in {} brackets and can contain nested blocks. Le code suivant illustre deux exemples d’instructions d’une ligne, et un bloc d’instructions multiligne :The following code shows two examples of single-line statements, and a multi-line statement block:

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

        // Assignment statement.
        counter = 1;

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

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

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

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

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

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

Types d’instructionsTypes of Statements

Le tableau suivant répertorie les différents types d’instructions en C# et leurs mots clés associés, avec des liens vers des rubriques contenant plus d’informations :The following table lists the various types of statements in C# and their associated keywords, with links to topics that include more information:

CategoryCategory Mots clés C# / RemarquesC# keywords / notes
Instructions de déclarationDeclaration statements Une instruction de déclaration introduit une nouvelle variable ou constante.A declaration statement introduces a new variable or constant. Une déclaration de variable peut éventuellement assigner une valeur à la variable.A variable declaration can optionally assign a value to the variable. Dans une déclaration de constante, l’assignation est obligatoire.In a constant declaration, the assignment is required.
Instructions d’expressionExpression statements Les instructions d’expression qui calculent une valeur doivent stocker la valeur dans une variable.Expression statements that calculate a value must store the value in a variable. Pour plus d’informations, consultez Instructions d’expression.For more information, see Expression Statements.
Instructions de sélectionSelection statements Les instructions de sélection permettent de créer des branches vers différentes sections de code, selon une ou plusieurs conditions spécifiées.Selection statements enable you to branch to different sections of code, depending on one or more specified conditions. Pour plus d’informations, consultez les rubriques suivantes :For more information, see the following topics:

if, else, switch, caseif, else, switch, case
Instructions d’itérationIteration statements Les instructions d’itération permettent d’exécuter une boucle dans des collections telles que des tableaux, ou d’effectuer à plusieurs reprises le même jeu d’instructions jusqu’à ce qu’une condition spécifiée soit remplie.Iteration statements enable you to loop through collections like arrays, or perform the same set of statements repeatedly until a specified condition is met. Pour plus d’informations, consultez les rubriques suivantes :For more information, see the following topics:

do, for, foreach, in, whiledo, for, foreach, in, while
Instructions de sautJump statements Les instructions de saut transfèrent le contrôle vers une autre section de code.Jump statements transfer control to another section of code. Pour plus d’informations, consultez les rubriques suivantes :For more information, see the following topics:

break, continue, default, goto, return, yieldbreak, continue, default, goto, return, yield
Instructions de gestion des exceptionsException handling statements Les instructions de gestion des exceptions permettent de récupérer normalement en cas de conditions exceptionnelles au moment de l’exécution.Exception handling statements enable you to gracefully recover from exceptional conditions that occur at run time. Pour plus d’informations, consultez les rubriques suivantes :For more information, see the following topics:

throw, try-catch, try-finally, try-catch-finallythrow, try-catch, try-finally, try-catch-finally
Checked et uncheckedChecked and unchecked Les instructions checked et unchecked vous permettent de spécifier si les opérations numériques sont autorisées à provoquer un dépassement de capacité lorsque le résultat est stocké dans une variable trop petite pour contenir la valeur résultante.Checked and unchecked statements enable you to specify whether numerical operations are allowed to cause an overflow when the result is stored in a variable that is too small to hold the resulting value. Pour plus d’informations, consultez checked et unchecked.For more information, see checked and unchecked.
Instruction awaitThe await statement Si vous marquez une méthode avec le modificateur async , vous pouvez utiliser l'opérateur await dans la méthode.If you mark a method with the async modifier, you can use the await operator in the method. Quand le contrôle atteint une expression await dans la méthode async, il retourne à l’appelant, et la progression dans la méthode est interrompue jusqu’à ce que la tâche attendue soit terminée.When control reaches an await expression in the async method, control returns to the caller, and progress in the method is suspended until the awaited task completes. Quand la tâche est terminée, l'exécution peut reprendre dans la méthode.When the task is complete, execution can resume in the method.

Pour obtenir un exemple simple, consultez la section « Méthodes async » de Méthodes.For a simple example, see the "Async Methods" section of Methods. Pour plus d’informations, consultez Programmation asynchrone avec async et await.For more information, see Asynchronous Programming with async and await.
Instruction yield returnThe yield return statement Un itérateur exécute une itération personnalisée sur une collection, comme une liste ou un tableau.An iterator performs a custom iteration over a collection, such as a list or an array. Un itérateur utilise l’instruction yield return pour retourner chaque élément un par un.An iterator uses the yield return statement to return each element one at a time. Quand une instruction yield return est atteinte, l’emplacement actuel dans le code est mémorisé.When a yield return statement is reached, the current location in code is remembered. L'exécution redémarre à partir de cet emplacement au prochain appel de l'itérateur.Execution is restarted from that location when the iterator is called the next time.

Pour plus d'informations, consultez Itérateurs.For more information, see Iterators.
Instruction fixedThe fixed statement L’instruction fixed empêche le récupérateur de mémoire de déplacer une variable mobile.The fixed statement prevents the garbage collector from relocating a movable variable. Pour plus d’informations, consultez fixed.For more information, see fixed.
Instruction lockThe lock statement L’instruction lock permet de limiter l’accès aux blocs de code à un seul thread à la fois.The lock statement enables you to limit access to blocks of code to only one thread at a time. Pour plus d’informations, consultez lock.For more information, see lock.
Instructions étiquetéesLabeled statements Vous pouvez donner une étiquette à une instruction, puis utiliser le mot clé goto pour sauter jusqu’à l’instruction étiquetée.You can give a statement a label and then use the goto keyword to jump to the labeled statement. (Examinez l’exemple de la ligne suivante.)(See the example in the following row.)
Instruction videThe empty statement L’instruction vide se compose seulement d’un point-virgule.The empty statement consists of a single semicolon. Elle ne fait rien et peut être utilisée à un emplacement où une instruction est requise alors qu’aucune action ne doit être effectuée.It does nothing and can be used in places where a statement is required but no action needs to be performed.

Instructions de déclarationDeclaration statements

Le code suivant montre des exemples de déclarations de variables avec et sans assignation initiale, ainsi qu’une déclaration de constante avec l’initialisation nécessaire.The following code shows examples of variable declarations with and without an initial assignment, and a constant declaration with the necessary initialization.

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

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

Instructions d’expressionExpression statements

Le code suivant montre des exemples d’instructions d’expression, y compris l’assignation, la création d’objets avec assignation et l’appel de méthode.The following code shows examples of expression statements, including assignment, object creation with assignment, and method invocation.

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

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

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

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

Instruction videThe empty statement

Les exemples suivants illustrent deux utilisations d’une instruction vide :The following examples show two uses for an empty statement:

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

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

Instructions incorporéesEmbedded Statements

Certaines instructions, y compris do, while, for et foreach, sont toujours suivies d’une instruction incorporée.Some statements, including do, while, for, and foreach, always have an embedded statement that follows them. Cette instruction incorporée peut être une seule instruction ou plusieurs instructions placées entre des accolades ({}) dans un bloc d’instructions.This embedded statement may be either a single statement or multiple statements enclosed by {} brackets in a statement block. Même les instructions incorporées d’une seule ligne peuvent être placées entre des accolades ({}), comme illustré dans l’exemple suivant :Even single-line embedded statements can be enclosed in {} brackets, as shown in the following example:

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

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

Une instruction incorporée qui n’est pas placée entre des accolades ({}) ne peut pas être une instruction de déclaration ni une instruction étiquetée.An embedded statement that is not enclosed in {} brackets cannot be a declaration statement or a labeled statement. Ceci est illustré dans l'exemple suivant :This is shown in the following example:

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

Placez l’instruction incorporée dans un bloc pour corriger l’erreur :Put the embedded statement in a block to fix the error:

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

Blocs d’instructions imbriquésNested Statement Blocks

Les blocs d’instructions peuvent être imbriqués, comme illustré dans le code suivant :Statement blocks can be nested, as shown in the following code:

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

}
return "Not found.";

Instructions inaccessiblesUnreachable Statements

Si le compilateur détermine que le flux de contrôle ne peut jamais atteindre une instruction particulière, il génère l’avertissement CS0162, comme illustré dans l’exemple suivant :If the compiler determines that the flow of control can never reach a particular statement under any circumstances, it will produce warning CS0162, as shown in the following example:

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

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also