Les structures de contrôle DI#

Modifié le : Jeu, 8 Janv., 2026 à 10:15 H

Dans DI#, les structures de contrôle permettent de diriger l’exécution du code selon des conditions ou de répéter des instructions sur des ensembles de données. Cet article présente les principales constructions telles que if, else, while et foreach, ainsi que leurs syntaxes et exemples d’utilisation dans des scripts DI#. Maîtriser ces structures est essentiel pour écrire des scripts DI# dynamiques et conditionnels qui s’adaptent aux données et au contexte du message.

if

L'instruction if est une des plus importantes instructions de tous les langages. Elle permet l'exécution conditionnelle d'une partie de code. Les fonctionnalités de l'instruction if sont les mêmes qu'en C.

if (expression)  
    commande ;

if (expression)  
{  
    Commandes 1 ;  
    Commandes 2 ;  
}

L’instruction if convertit son expression en sa valeur booléenne. Si l'expression vaut TRUE, DI# exécutera l'instruction et si elle vaut FALSE, l'instruction sera ignorée.

// L'exemple suivant affiche la phrase « a est plus grand que b » si a est plus grand que b :
                [[  
int a = 1;  
int b = 2;  
if (a > b)  
    output.write("a est plus grand que b");  
]]

Vous pouvez imbriquer indéfiniment des instructions if dans d'autres instructions if, ce qui permet une grande flexibilité dans l'exécution d'une partie de code suivant un grand nombre de conditions.

else

Souvent, vous voulez exécuter une instruction si une condition est remplie, et une autre instruction si cette condition n'est pas remplie. C'est à cela que sert else. else fonctionne après un if et exécute les instructions correspondantes au cas où l'expression du if est FALSE.

/* Dans l'exemple suivant, ce bout de code affiche « a est 
plus grand que b » si la variable a est plus grande que la variable b, et « a est plus petit que b » dans le cas 
contraire :  
*/
[[  
int a = 1;  
int b = 2;  
if (a > b) {  
    output.write("a est plus grand que b");  
} else {  
    output.write("a est plus petit que b");  
}  
]]

if/else raccourci

Comme en C#, il est possible d’utiliser un raccourci à l’instruction if/else en utilisant l’opérateur conditionnel ? : tel que :
(condition) ? (expression_si_vrai) : (expression_si_faux);

[[  
int a = 1;  
int b = 2;  
output.write((a > b) ? "a est plus grand que b" : "a est plus petit que b");  
]]

Note : Dû à des limitations du compilateur DI#, assurez-vous de placer la condition entre parenthèses lorsque vous utilisez cette forme.

while

La boucle while est le moyen le plus simple d'implémenter une boucle en DI#. Cette boucle se comporte de la même manière qu'en C.

// L'exemple le plus simple d'une boucle while est le suivant :
                while (expression)  
    commande ;
    
    OU
    
    while (expression)  
{  
    Commandes 1 ;  
    Commandes 2 ;  
}

// L’exemple suivant affiche tous les nombres de 1 jusqu'à 10 :
            [[  
int a = 1;  
while (a <= 10)  
{  
    output.write(a);  
    a+=1;  
}  
]]

Note : Portez attention à la gestion de vos variables qui contrôlent la boucle pour ne pas créer une boucle sans fin. Par mesure de protection, l’exécution des boucles while en DI# prend fin automatiquement dès que 250 itérations sont atteintes.

foreach

→ Itération sur un tableau

La structure de langage foreach fournit une façon simple de parcourir des tableaux.

foreach (identifier in expression) 
commande ;

foreach (identifier in expression) 
{  
commande 1 ;  
commande 2 ;  
}

Dans cette structure, «identifier» est le nom que l’on choisit pour la qui itère les valeurs du tableau retourné par l’« expression ». Cette variable doit être du même type que les valeurs du tableau.

/* L’exemple suivant montre comment afficher tous les éléments d’un simple tableau de nombres entiers :
*/  
[[  
int myArray[] = { 1, 2, 3, 4, 5};  
foreach(number in myArray)  
{  
output.write(number);  
}  
]]

→ Utilisation d'une expression complexe

Puisqu’un foreach permet d’itérer n’importe quel tableau issu d’une expression, il est possible d’utiliser des expressions complexes directement dans la structure du foreach, comme une expression de requête (voir leurs utilisations dans la partie précédente).

[[  
datasource myArray =  
{  
    { Prenom : "Jean", Nom : "Tremblay", Age : 40 },  
    { Prenom : "John", Nom : "Smith", Age : 30 }  
};  
foreach(Namevalue in  (select item.Nom  
                      from item in myArray  
                      order by (item.Age)))  
{  
    output.write("Nom :" + Namevalue);  
}  
]]

→ Itération avec compteur

Comme dans de nombreux langages, il est possible d’entretenir un compteur pendant que l’on itère les valeurs de l’expression :
foreach (compteur => identifier in expression)
commande ;

Dans cette structure, « compteur » est le nom d’une variable qui est un nombre entier initialisé à 0 qui s’incrémentera à chaque itération de l’expression.

[[  
int myArray[] = { 1, 2, 3, 4, 5};  
foreach(itemOrder => number in myArray)  
{  
    output.write("position : " + itemOrder);  
    output.write("valeur : " + number);  
}  
]]

Note : tout comme pour la boucle while, une boucle foreach s’interrompt automatiquement après 250 itérations.

break

/* L'instruction break permet de sortir d'une structure itérative foreach ou while. L’exemple suivant permet de « casser » la boucle du foreach afin de n’afficher que les 3 premiers nombres :  
*/
  [[
  int myArray[] = { 1, 2, 3, 4, 5};  
  foreach(number in myArray)  
    {    
            	output.write(number); 
                if (number == 3)
 		    break;
    }
  ]]

switch

L'instruction switch équivaut à une série d'instructions if. En de nombreuses occasions, vous aurez besoin de comparer la même variable (ou expression) avec un grand nombre de valeurs différentes, et d'exécuter différentes parties de code suivant la valeur à laquelle elle est égale. C'est exactement à cela que sert l'instruction switch.

Switch (expression) { case valeur : commande; }

Switch (expression)  
{  
case valeur :  
{  
commande 1;  
commande 2;  
}  
}

/* Les deux exemples suivants sont deux manières différentes d'écrire la même chose, l'une en utilisant une série de if, et l'autre en utilisant l'instruction switch :
*/  
[[  
int i = 0;  
if (i == 0)  
    output.write("i égal 0");  
if (i == 1)  
    output.write("i égal 1");  
if (i == 2)  
    output.write("i égal 2");  
switch (i)  
{  
    case 0:  
        output.write("i égal 0");  
    case 1:  
        output.write("i égal 1");  
    case 2: 
    {  
        output.write("i égal 2");  
        output.write("i égal 2");  
    }  
}  
]]

Contrairement à d’autres langages, il n’est pas nécessaire d’utiliser l’instruction break dans un switch de DI#. En effet, dès qu’un des cas est respecté, ses instructions seront exécutées et le compilateur sortira immédiatement du switch. Notez qu’il n’y a également pas de default dans le DI#, ainsi si aucun cas n’est respecté, le switch n’exécutera aucune instruction.

continue

L'instruction continue est utilisée dans une boucle afin d'éluder les instructions de l'itération courante et de continuer l'exécution à la condition de l'évaluation et donc, de commencer la prochaine itération.

[[  
Datasource myArray[] = { 1, 2, 3, 4, 5};  
foreach(number in myArray)  
{  
  if (number == 3)  
      continue;  
output.write(number);  
}  
]]

Un continue arrête donc immédiatement les instructions de la boucle et passe à la prochaine itération.

return

L’instruction return retourne le contrôle du programme au module appelant. L'exécution reprend alors à l'endroit de l'invocation du module.

Si appelée depuis une fonction, la commande return termine immédiatement la fonction, et retourne l'argument qui lui est passé.
Si appelée depuis l'environnement global, l'exécution du script est interrompue.

Return accepte une valeur de retour optionnel. Ceci permet d’assigner à une variable le résultat de ce qui a mis fin au script.

/* Dans l’exemple suivant l’instruction return, en plus d’arrêter le l’exécution de la fonction checkNumber retourne une valeur qui peut être assigné directement à une variable :
*/
            [[ 
            	string checkNumber(int x) 
                {
                	if (x == 0) 
                    	   return "x égal 0";
                   	if (x == 1) 
                    	   return "x égal 1"; 
                        if (x == 2) 
                    	   return "x égal 2"; 
                } 
                string result = checkNumber(1); 
                output.write(result); 
                // Affiche "x égal 1" 
                ]]

Note : si l’instruction return est utilisée à la racine du script, ceci stoppe l’exécution complète du script et la valeur retournée par return peut dans certains cas remplacer ce que le script aurait dû afficher.

French