5. Instructions

L'exécution d'un programme C# est réalisée par l'exécution séquentielle d'une série d'instructions suivant l'ordre dans lesquelles elles apparaissent. Toutes les instructions dans un langage procédural tel que C# sont exécutées pour leur effet.
Des instructions multiples peuvent être groupées ensemble; 0 ou plus d'instructions doivent être comprises entre une paire d'accolades pour former un bloc d'instructions.

5.1. Instructions d'expression

Une instruction d'expression évalue une expression, assigne son résultat a une variable ou génère un effet de bord (side effect) (c-à-d un appel de méthode, new, ++, --). Une instruction d'expression est terminée avec un point-virgule.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionsExpression
    {
        static void Main(string[] args)
        {
            int g3391 = 33 + 91; // assigne un résultat
            Console.WriteLine(g3391); // affiche 124
            g3391++; // effet de bord (side effect)
            Console.WriteLine(g3391); // affiche 125
            int g33 = Math.Min(g3391, 33); // effet de bord et assigne le résultat
            Console.WriteLine(g33); // affiche 33
            Console.ReadKey();
        }
    }
}

124
125
33

Assignations et effets de bord...

5.2. Instructions de déclaration

Une instruction de déclaration déclare une nouvelle variable et assigne optionnellement le résultat d'une expression à cette variable. Une instruction de déclaration est terminée avec un point virgule.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionsDeclaration
    {
        static void Main(string[] args)
        {
            int g33 = 33; // déclaration de variable
            const decimal pi = 3.14159M; // déclaration d'une constante
            Console.WriteLine(g33); // affiche 33
            Console.WriteLine(pi); // affiche 3,14159
            Console.ReadKey();
        }
    }
}

33
3,14159

Déclarations...

La portée d'une variable locale ou d'une constante s'étend jusqu'à la fin du bloc courant. Vous ne pouvez pas déclarer une autre variable locale avec le même nom au sein du même bloc ou dans des blocs compris dans ce bloc.
La déclaration d'une constante (en utilisant le mot-clé const) est similaire à une déclaration de variable, excepté qu'elle ne peut pas être modifiée après avoir été déclarée.

5.3. Instructions de sélection

C# dispose de nombreuses façons de contrôler le flux d'exécution conditionnel d'un programme. Cette section couvre les deux constructions les plus simples :

l'instruction if-else et
l'instruction switch.

De plus, C# fournit un opérateur et des instructions de boucle s'exécutant de manière conditionnelle basée sur une expression booléenne.
Enfin, C# fournit des moyens orientés objet pour contrôler conditionnellement le flux d'exécution, à savoir les appels de méthodes virtuelles et les appels de délégués.

5.3.1. L'instruction if-else

Une instruction if-else exécute le code selon le résultat d'une expression booléeenne.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionIfElse
    {
        static int Compare(int a, int b)
        {
            if (a > b)
                return 1;
            else if (a < b)
                return -1;
            return 0;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Compare(91, 33)); // affiche 1
            Console.WriteLine(Compare(33, 33)); // affiche 0
            Console.WriteLine(Compare(33, 91)); // affiche -1
            Console.ReadKey();
        }
    }
}

1
0
-1

Dans cet exemple, la méthode Compare retourne :

1 si a > b,
-1 si a < b et
0 si a = b.

Il est très courant d'utiliser les opérateur ||, && et ! pour tester les conditions ET, OU et NON.

5.3.2. L'instruction switch

L'instruction switch rendra le code plus clair qu'en employant plusieurs instructions if, puisqu'une instruction switch ne demande qu'une seule évaluation de l'expression.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionSwitch1
    {
        static string Note(int n)
        {
            switch (n)
            {
                case 1:
                    return "Peut mieux faire !";
                    break;
                case 2:
                    return "Bof !";
                    break;
                case 3:
                    return "Pas mal !";
                    break;
                case 4:
                    return "Bien !";
                    break;
                case 5:
                    return "Magnifique !";
                    break;
                default:
                    return "Comment ?";
                    break;
            }
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Note(1)); // affiche Peut mieux faire !
            Console.WriteLine(Note(3)); // affiche Pas mal !
            Console.WriteLine(Note(5)); // affiche Magnifique !
            Console.WriteLine(Note(33)); // affiche Comment ?
            Console.ReadKey();
        }
    }
}

Peut mieux faire !
Pas mal !
Magnifique !
Comment ?

Exemple d'instruction switch...

L'instruction switch peut seulement évaluer un type prédéfini (y compris le type string) ou une énumération.
La fin de chaque instruction case doit être inaccessible. Ceci signifie en général que chaque instruction case doit être terminée par une instruction de saut. Voici les options possibles :

Utilisez l'instruction break pour vous rendre à la fin de l'instruction switch (c'est de loin l'option la plus commune),
Utilisez l'instruction goto case <expression constante> ou l'instruction goto default pour sauter à une autre instruction case ou à l'instruction default case ou
Utilisez n'importe quelle autre instruction de saut, tel que return, throw, continue ou les étiquettes goto.

Attention, en ne spécifiant pas une rupture, la prochaine instruction case sera exécutée...

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionSwitch2
    {
        static void Salutation(string titre)
        {
            switch (titre)
            {
                case null:
                    Console.WriteLine("Et vous êtes ?");
                    goto default;
                case "Roi":
                    Console.WriteLine("Salutation, votre grandeur !");
                    break;
                default:
                    Console.WriteLine("Quoi d'neuf Docteur ?");
                    break;
            }
        }
        static void Main(string[] args)
        {
            Salutation(null); // affiche "Et vous êtes ? Quoi d'neuf Docteur ?
            Salutation("Monsieur"); // affiche Quoi d'neuf Docteur ?
            Salutation("Roi"); // affiche Salutation, votre grandeur !
            Console.ReadKey();
        }
    }
}

Et vous êtes ?
Quoi d'neuf Docteur ?
Quoi d'neuf Docteur ?
Salutation, votre grandeur !

La fin d'une instruction case doit exprimer explicitement où aller après...

5.4. Instructions de boucle

C# permet qu'une séquence d'instructions soit exécutée de manière répétitive avec les instructions while, do while, for et foreach.

5.4.1. Les boucles while

Les boucles while exécutent de manière répétitive un bloc d'instructions tant qu'une expression booléenne est vraie. L'expression est testée avant que le bloc d'instructions ne soit exécuté.

Code	Résultat	Remarques
using System; namespace Exemples { class BouclesWhile { static void Main(string[] args) { int i = 0; while (i < 3) { Console.WriteLine(i); // affiche 0 1 2 i++; } Console.ReadKey(); } } }	0 1 2	La boucle peut ne pas s'exécuter si la condition est fausse dés le départ...

5.4.2. Les boucles do-while

Les boucles do-while diffèrent des boucles while uniquement dans le fait qu'elles n'évaluent l'expression qu'après le bloc d'instructions ait été exécuté.

Code	Résultat	Remarques
using System; namespace Exemples { class BouclesDoWhile { static void Main(string[] args) { int i = 33; do { Console.WriteLine(i); // affiche 33 i++; } while (i < 3); Console.ReadKey(); } } }	33	Dans cette exemple, la boucle do-while affiche 33, une boucle while n'afficherait rien...

5.4.3. Les boucles for

les boucles for peuvent être plus commodes que les boucles while lorsque vous devez piloter une valeur itérative.
Les boucles for contiennent trois parties :

la première est l'instruction exécutée avant que la boucle ne démarre, et par convention, est utilisée pour initialiser une vaiable itérative,
la seconde est une expression booléenne qui, tant qu'elle est vraie, exécute le bloc d'instructions et
la troisième est une instruction qui est exécutée après chaque itération du bloc d'instructions, ce qui par convention est utilisé pour itérer la variable itérative.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class BouclesFor
    {
        static void Main(string[] args)
        {
            for (int i = 1; i < 4; i++)
                Console.WriteLine(i); // affiche 1 2 3
            Console.WriteLine("Nous irons au bois...");
            Console.ReadKey();
        }
    }
}

1
2
3
Nous irons au bois...

4 5 6 Cueillir des cerises...

5.4.4. Les boucles foreach

Il est très courant pour les boucles for d'itérer sur une série d'élements, ainsi C# a une instruction foreach adaptée à cette problématique.

Code

Résultat

Remarques

using System;
using System.Collections;

namespace Exemples
{
    class Baton
    {
        private int _longueurMeche; // en mm
        private const int vitesse = 3; // en mm/s;

        // Propriété : longeur de la mèche
        public int LongueurMeche
        {
            get { return _longueurMeche; }
            set { _longueurMeche = value; }
        }

        // Constructeur du Baton
        public Baton(int l)
        {
            LongueurMeche = l;
        }

        // Calcul du temps avant l'explosion
        // en fonction de la longueur de la mèche
        public int Temps()
        {
            return LongueurMeche * vitesse ;
        }
    }

    class BouclesForeach
    {
        static void Main(string[] args)
        {
            // Création de la dynamite
            Baton[] dynamite = new Baton[3];

            // Création de 3 bâtons de dynamite
            dynamite[0] = new Baton(5);
            dynamite[1] = new Baton(33);
            dynamite[2] = new Baton(91);

            // affichage du temps avant l'explosion pour chaque bâton
            Console.WriteLine("Avec foreach");
            foreach (Baton baton in dynamite)
                Console.WriteLine("Boom dans " + baton.Temps() + " s");

            Console.WriteLine("Avec IEnumerator");
            IEnumerator ie = dynamite.GetEnumerator();
            while (ie.MoveNext())
            {
                Baton baton = (Baton)ie.Current;
                Console.WriteLine("Boom dans " + baton.Temps() + " s");
            }
            Console.ReadKey();
        }
    }
}

Avec foreach
Boom dans 15 s
Boom dans 99 s
Boom dans 273 s
Avec IEnumerator
Boom dans 15 s
Boom dans 99 s
Boom dans 273 s

Exemple d'une boucle foreach sur 3 bâtons de dynamite, puis avec while en utilisant IEnumerator...

L'instruction foreach fonctionne sur toutes les collections (y compris les tableaux).
Bien que ce ne soit pas nécessaire, toutes les collections optimisent cette fonctionnalité en supportant IEnumerable et IEnumerator (voir le sujet Enumerating a Collection dans la documentation du .NET Framework SDK). Vous pouvez voir la mise en oeuvre dans l'exemple précédent...

5.5. Instructions de saut

Les instructions de saut sont break, continue, goto, return et throw. Toutes les instructions de saut obéissent à des restrictions imposées par l'instruction try :

premièrement, un saut en dehors d'un bloc try exécute toujours le bloc finally du bloc try avant d'atteindre la cible du saut et
deuxièmement, un saut ne peut pas être exécuté de l'intérieur d'un bloc finally vers l'extérieur.

5.5.1. L'instruction break

L'instruction break transfère l'exécution comprise dans une boucle while, une boucle for, ou un bloc d'instructions switch vers le prochain bloc d'instructions.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionBreak
    {
        static void Main(string[] args)
        {
            int i = 0;
            while (true)
            {
                Console.WriteLine(i);
                i++;
                if (i > 5)
                    break; // cesse la boucle
            }
            Console.ReadKey();
        }
    }
}

Dans cet exemple, on sort de la boucle lorsque le compteur devient plus grand que 5...

5.5.2. L'instruction continue

L'instruction continue devance les instructions restantes dans la boucle et démarre prématurément la prochaine itération.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionContinue
    {
        static void Main(string[] args)
        {
            int i = 0;
            while (i < 10)
            {
                if ((i % 2) == 0)
                {
                    i++;
                    continue; // continue avec la prochaine itération
                }
                Console.WriteLine(i);
                i++;
            }
            Console.ReadKey();
        }
    }
}

Affichage des chiffres impaires...

5.5.3. L'instruction goto

L'instruction goto transfère l'exécution vers une autre étiquette dans le bloc d'instruction.
Une instruction d'étiquette est juste un nom d'emplacement dans une méthode.

Code	Résultat	Remarques
using System; namespace Exemples { class InstructionGoto { static void Main(string[] args) { int i = 0; debut: Console.WriteLine(i); i++; if (i <= 5) goto debut; Console.ReadKey(); } } }	0 1 2 3 4 5	Dans cette exemple, on retourne à l'étiquette debut tant que le compteur est inférieur ou égal à 5...

Comme expliqué plus haut, vous pouvez utiliser goto dans une instruction case pour transférer l'exécution vers une autre étiquette case dans un bloc switch.

5.5.4. L'instruction return

L'instruction return sort de la méthode et doit retourner une expression du type de retour de la méthode.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionReturn
    {
        static int Carre(int x)
        {
            return x * x; // retourne le carré de x
        }

        static void Main(string[] args)
        {
            Console.WriteLine(Carre(3)); // affiche 9
            Console.ReadKey();
        }
    }
}

Affiche le carré d'un nombre entier passé en argument à la fonction Carre...

5.5.5. L'instruction throw

L'instruction throw provoque une exception pour indiquer qu'une condition anormale est survenue.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    class InstructionThrow
    {
        static void Main(string[] args)
        {
            try
            {
                int n = 33;
                int d = 0;
                if (d == 0)
                    throw new ArgumentException("d ne peut pas être égal à 0");
                Console.WriteLine(n / d); // affiche le résultat de la division
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
    }
}

d ne peut pas être égal à 0

On ne peut pas diviser par 0...

Pour plus d'information :
Enumerating a Collection : http://msdn.microsoft.com/en-us/library/hwyysy67%28v=vs.95%29.aspx