Partager via

Instructions (Guide de programmation C#)

Les actions qu’un programme prend sont exprimées dans des instructions. Les actions courantes incluent la déclaration de variables, l’affectation de valeurs, l’appel de méthodes, la boucle dans des collections et la branche vers un ou 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 se composer d’une seule ligne de code qui se termine par un point-virgule ou d’une série d’instructions à une seule ligne dans un bloc. Un bloc d’instructions est placé entre {} crochets et peut contenir des blocs imbriqués. Le code suivant montre deux exemples d’instructions monolignes et un bloc d’instructions à plusieurs lignes :

    public 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 #{counter} is {radius}. Circumference = {circumference:N2}");

            // 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 de déclarations

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 qui incluent plus d’informations :

Catégorie Mots clés C# / Remarques
Déclarations Une instruction de déclaration introduit une nouvelle variable ou une constante. Une déclaration de variable peut éventuellement affecter une valeur à la variable. Dans une déclaration de constante, l’assignation est obligatoire.
Instructions d’expression Les instructions d’expression qui calculent une valeur doivent stocker la valeur dans une variable.
Instructions de sélection Les instructions de sélection vous permettent de créer une branche vers différentes sections de code, selon une ou plusieurs conditions spécifiées. Pour plus d’informations, consultez les rubriques suivantes :
Instructions d’itération Les instructions d’itération vous permettent de parcourir des collections telles que des tableaux ou d’effectuer le même jeu d’instructions à plusieurs reprises jusqu’à ce qu’une condition spécifiée soit remplie. Pour plus d’informations, consultez les rubriques suivantes :
Instructions de saut Les instructions de saut transfèrent le contrôle vers une autre section de code. Pour plus d’informations, consultez les rubriques suivantes :
Instructions de gestion des exceptions Les instructions de gestion des exceptions permettent de récupérer normalement en cas de conditions exceptionnelles au moment de l’exécution. Pour plus d’informations, consultez les rubriques suivantes :
checked et unchecked Les checked et unchecked instructions vous permettent de spécifier si les opérations numériques de type intégral sont autorisées à provoquer un débordement lorsque le résultat est stocké dans une variable dont la capacité est limitée pour contenir la valeur résultante.
L’instruction await. Si vous marquez une méthode avec le modificateur async, vous pouvez utiliser l’opérateur await dans la méthode. Lorsque le contrôle atteint une await expression dans la méthode asynchrone, le contrôle retourne à l’appelant et la progression de la méthode est suspendue jusqu’à ce que la tâche attendue se termine. Quand la tâche est terminée, l'exécution peut reprendre dans la méthode.

Pour obtenir un exemple simple, consultez la section « Méthodes asynchrones » des méthodes. Pour plus d’informations, consultez Programmation asynchrone avec async et await.
L’instruction yield return. Un itérateur exécute une itération personnalisée sur une collection, comme une liste ou un tableau. Un itérateur utilise l'instruction yield return pour retourner chaque élément un par un. Lorsqu’une yield return instruction est atteinte, l’emplacement actuel dans le code est mémorisé. L’exécution est redémarrée à partir de cet emplacement lorsque l’itérateur est appelé la prochaine fois.

Pour plus d'informations, consultez Itérateurs.
L’instruction fixed. L’instruction fixe empêche le garbage collector de déplacer une variable mobile. Pour plus d’informations, consultez fixed.
L’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 verrouillage.
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 dans la ligne suivante.)
Déclaration vide L’instruction vide se compose seulement d’un point-virgule. Elle ne fait rien et peut être utilisée dans des endroits où une instruction est requise, mais il n'est pas nécessaire d'effectuer d'action.

Instructions de déclaration

Le code suivant montre des exemples de déclarations de variables avec et sans affectation initiale, ainsi qu’une déclaration constante avec l’initialisation nécessaire.

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

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

Instructions d’expression

Le code suivant montre des exemples d’instructions d’expression, notamment l’affectation, la création d’objets avec l’assignation et l’appel de méthode.

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

// Expression statement (result discarded).
int x = 0;
x++;

// 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 vide

Les exemples suivants montrent deux utilisations pour 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, par exemple les instructions d’itération, ont toujours une instruction incorporée qui les suit. Cette instruction incorporée peut être une instruction unique ou plusieurs instructions placées {} entre crochets dans un bloc d’instructions. Même les instructions incorporées d’une seule ligne peuvent être placées entre des 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 entre {} crochets ne peut pas être une instruction de déclaration ou une instruction étiquetée. Ceci est illustré dans l'exemple suivant :

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

Placez l’instruction incorporée dans un bloc pour corriger 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 dans des circonstances quelconques, il génère un 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
}

Spécification du langage C#

Pour plus d’informations, consultez la section Instructions de la spécification du langage C#.

Voir aussi