Instructions (Guide de programmation C#)

Les actions effectuées par un programme sont exprimées dans des instructions. Les actions courantes incluent la déclaration de variables, l'attribution de valeurs, l'appel de méthodes, l'exécution de boucle à travers des collections et le branchement à un autre bloc de code, en fonction d'une condition donnée. L'ordre dans lequel les instructions sont exécutées dans un programme est appelé flux de contrôle ou flux d'exécution. Le flux de contrôle peut varier chaque fois qu'un programme est exécuté, selon la façon dont le programme réagit à l'entrée qu'il reçoit au moment de l'exécution.

Une instruction peut être constituée d'une ligne unique de code qui se termine par un point-virgule, ou d'une série d'instructions sur une ligne dans un bloc. Un bloc d'instructions est placé entre accolades {} et peut contenir des blocs imbriqués. Le code suivant illustre deux exemples d'instructions sur une ligne et un bloc d'instructions multiligne :

    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'instructions

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 proposant davantage d'informations :

Catégorie	Mots clés C# / remarques
Instructions de déclaration	Une instruction de déclaration introduit une nouvelle variable ou constante. Une déclaration de variable peut éventuellement assigner une valeur à la variable. Dans une déclaration de constante, l'assignation est requise. // Variable declaration statements.  double area; double radius = 2; // Constant declaration statement.  const double pi = 3.14159;
Instructions d'expression	Les instructions d'expression qui calculent une valeur doivent stocker la valeur dans une variable. // 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>();
Instructions de sélection	Les instructions de sélection permettent de se brancher à différentes sections de code, en fonction d'une ou plusieurs conditions spécifiées. Pour plus d’informations, voir les rubriques suivantes : if, else, switch, case
Instructions d'itération	Les instructions d'itération permettent d'effectuer une boucle à travers des collections telles que des tableaux, ou d'exécuter à plusieurs reprises le même jeu d'instructions jusqu'à ce qu'une condition spécifiée soit remplie. Pour plus d’informations, voir les rubriques suivantes : do, for, foreach, in, while
Instructions de saut	Les instructions de saut transfèrent le contrôle à une autre section de code. Pour plus d’informations, voir les rubriques suivantes : break, continue, default, goto, return, yield
Instructions de gestion des exceptions	Les instructions de gestion des exceptions vous permettent d'effectuer une récupération « propre » suite à des conditions d'exception qui se produisent au moment de l'exécution. Pour plus d’informations, voir les rubriques suivantes : throw, try-catch, try-finally, try-catch-finally
Checked et 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 qui est trop petite pour contenir la valeur résultante. Pour plus d'informations, consultez checked et unchecked.
Instruction await	Si vous marquez une méthode avec le modificateur d' async , vous pouvez utiliser l'opérateur d' attendez dans la méthode. Lorsque le contrôle atteint une expression d' await dans la méthode async, le contrôle retourne à l'appelant, et la progression de la méthode est interrompue jusqu'à ce que la tâche se termine attendue. Lorsque la tâche est terminée, l'opération peut continuer dans la méthode. Pour obtenir un exemple simple, consultez la section « méthodes Async » de Méthodes (guide de programmation C#). Pour plus d’informations, consultez Programmation asynchrone avec Async et Await (C# et Visual Basic).
Instruction yield return	Un itérateur effectue une itération au sein d'une collection, telle qu'une liste ou un tableau. Un itérateur utilise l'instruction de retour yield pour retourner les éléments un par un. Lorsqu'une instruction d' yield return est atteinte, la position actuelle dans le code est retrouvée. L'exécution est redémarrée de cet emplacement lorsque l'itérateur s'agit de la prochaine fois. Pour plus d’informations, consultez Itérateurs (C# et Visual Basic).
Instruction fixed	L'instruction fixed empêche le Garbage Collector de déplacer une variable mobile. Pour plus d'informations, consultez fixed.
Instruction lock	L'instruction lock vous permet de limiter l'accès aux blocs de code à un seul thread à la fois. Pour plus d'informations, consultez lock.
Instructions étiquetées	Vous pouvez donner une étiquette à une instruction puis utiliser le mot clé goto pour accéder à l'instruction étiquetée. (Consultez l'exemple sur la ligne suivante.)
Instruction vide	L'instruction vide se compose d'un point-virgule unique. Elle ne fait rien et peut être utilisée à des emplacements où une instruction est requise mais aucune action ne doit être exécutée. Les exemples suivants illustrent deux utilisations d'une instruction vide : void ProcessMessages() { while (ProcessMessage()) ; // Statement needed here. } void F() { //...  if (done) goto exit; //... exit: ; // Statement needed here. }

Instructions incorporées

Certaines instructions, y compris do, while, for et foreach, sont toujours suivies d'une instruction incorporée. Cette instruction incorporée peut être une instruction unique ou plusieurs instructions placées entre accolades {} dans un bloc d'instructions. Même les instructions incorporées sur une ligne peuvent être placées entre accolades {}, comme illustré dans l'exemple suivant :

// 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 accolades {} ne peut pas être une instruction de déclaration ni une instruction étiquetée. Ceci est démontré dans l'exemple suivant :

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

Placez l'instruction incorporée dans un bloc pour résoudre l'erreur :

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

Blocs d'instructions imbriqués

Les blocs d'instructions peuvent être imbriqués, comme illustré dans le code suivant :

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 inaccessibles

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 :

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

Rubriques connexes

• Mots clés d'instruction (Référence C#)

• Expressions (Guide de programmation C#)

• Opérateurs (guide de programmation C#)

Spécification du langage C#

Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Concepts

Guide de programmation C#