Plan de ce chapitre:   ...........

Les instructions de base de C# sont identiques syntaxiquement et sémantiquement à celles de Java, le lecteur qui connaît déjà le fonctionnement des instructions en Java peut ignorer ce chapitre et passer au chapitre suivant.

1. instructions-bloc

2. L'affectation

2.1 Affectation simple
2.2 Raccourcis et opérateurs d'affectation

3. Les conditions

3.1 les instructions conditionnelles
3.2 l'opérateur conditionnel

4. Les itérations

4.1 Itération while
4.2 Itération do...while
4.3 Itération for

5.Break et continue

7.try...catch
 

Les instructions de base de C# sont identiques syntaxiquement et sémantiquement à celles de Java, le lecteur qui connaît déjà le fonctionnement des instructions en Java peut ignorer ce chapitre.

1. instructions-bloc
 
 Une large partie de la norme ANSI du langage C est reprise dans C#, ainsi que la norme Delphi. 

• Les commentaires sur une ligne débutent par //.... comme en Delphi
• Les commentaires sur plusieurs lignes sont encadrés par /*  ...   */

Dans ce sous-chapitre nous expliquons les instructions C#  en les comparant à pascal-delphi. Voici la syntaxe d'une instruction en C#  :

1.1 instruction :

 

1.2 instruction complète :

Toutes les instructions se terminent donc en C#  par un point-virgule " ; "
 
 

1.3 bloc - instruction composée :
L'élément syntaxique

est aussi dénommé bloc ou instruction composée au sens de la visibilité des variables C# .
 
 

1.4 visibilité dans un bloc - instruction  :

Exemple de déclarations licites et de visibilité dans 3 blocs instruction imbriqués :

int a, b = 12;    { int x , y = 8 ;      { int z =12;             x = z ;             a = x + 1 ;         { int u = 1 ;             y = u - b ;          }      }    }

schéma d'imbrication des 3 blocs

Nous examinons ci-dessous l'ensemble des instructions simples de C# .

C# est un langage de la famille des langages hybrides, il possède la notion d'instruction d'affectation.

Le symbole d'affectation en C# est  " = ", soit par exemple :
 

x = y ;  // x doit obligatoirement être un identificateur de variable.

 

2.1 Affectation simple

L'affectation peut être utilisée dans une expression :

soient les instruction suivantes  :
 

simulation d'exécution C# :

instruction	valeur de a	valeur de b
int a , b = 56 ;	a = ???	b = 56
a = (b = 12)+8 ;	a = 20	b = 12

 

2.2 Raccourcis et opérateurs d'affectation

Soit op un opérateur  appartenant à l'ensemble des opérateurs suivant 

{ +, - , * , / , % , << , >> , >>> , & , | , ^ }

Il est possible d'utiliser sur une seule variable le nouvel opérateur op= construit avec l'opérateur op.
 

x op= y ;     signifie en fait  :   x = x op y

simulation d'exécution C# :

instruction	valeur de a	valeur de b
int a , b = 56 ;	a = ???	b = 56
a = -8 ;	a = -8	b = 56
a += b ;	a = 48	b = 56
b *= 3 ;	a = 48	b = 168

Remarque :

• Cas d'une optimisation intéressante dans l'instruction suivante :

table[ f(a) ] = table[ f(a) ] + x ; // où f(a) est un appel à la fonction f qui serait longue à calculer.
 
• Si l'on réécrit l'instruction précédente  avec l'opérateur  += :

table[ f(a) ] +=  x ; //  l'appel à f(a) n'est effectué qu'une seule fois

3.1 les instructions conditionnelles

Syntaxe :

Schématiquement les conditions sont de deux sortes :

• if ( Expr ) Instr ;
• if ( Expr ) Instr ; else Instr ;

La définition de l'instruction conditionnelle de C# est classiquement celle des langages algorithmiques; comme en pascal  l'expression doit être de type booléen (différent du C), la notion d'instruction a été définie plus haut.

Exemple d'utilisation du if..else (comparaison avec pascal)

Pascal-Delphi	C#
var a , b , c : integer ; .... if  b=0 then c := 1 else begin c := a / b; writeln("c = ",c); end; c := a*b ; if c <>0 then c:= c+b else c := a	int a , b , c ; .... if ( b = = 0 ) c =1 ; else { c = a / b; System.Console.WriteLine("c = " + c); } if ((c = a*b) != 0) c += b; else c = a;

Remarques :

• L'instruction  " if ((c = a*b) != 0) c +=b; else c = a; " contient une affectation intégrée dans le test afin de vous montrer les possibilités de C# : la valeur de a*b est rangée dans c avant d'effectuer le test sur c.

• Comme pascal, C# contient le manque de fermeture des instruction conditionnels ce qui engendre le classique problème du dandling else d'algol, c'est le compilateur qui résoud l'ambigüité par rattachement du else au dernier if rencontré (évaluation par la gauche.

• Comme en pascal, si l'on veut que l'instruction else InstrB  ; soit rattachée au premier if, il est nécessaire de parenthéser (introduire un bloc) le second if :

Exemple de parenthésage du else pendant

Pascal-Delphi	C#
if  Expr1  then begin    if  Expr2  then InstrA  end else InstrB	if ( Expr1 ) {      if ( Expr2 ) InstrA ;  } else InstrB

 
 

3.2 l'opérateur conditionnel

Il s'agit ici comme dans le cas des opérateurs d'affectation d'une sorte de raccourci entre l'opérateur conditionnel if...else et l'affectation. Le but étant encore d'optimiser le bytecode engendré.

Syntaxe :

Où expression est une expression renvoyant une valeur booléenne (le test), valeur sont des expressions genérales (variable, expression numérique, boolénne etc...) renvoyant une valeur de type T.

Sémantique :
Exemple :

Sémantique de l'exemple avec un if..else :

1 . Code MSIL engendré pour l'instruction C#  : c =   a = = 0  ?  b  :  a+1 ;

une seule opération de stockage pour c : IL_0010:  stloc.2

2 . Code MSIL engendré pour l'instruction C#  : if (a = = 0) c = b; else c = a+1 ;

deux opérations de stockage pour c :

Le code MSIL engendré a la même structure classique de code de test pour les deux instructions, la traduction de l'opérateur sera légèrement plus rapide que celle de l'instructions car, il n'y a pas besoin de stocker deux fois le résultat du test dans la variable c (qui ici, est représentée par l'instruction MSIL stloc.2)

question :

4.1.Itération while

Syntaxe :

Où expression est une expression renvoyant une valeur booléenne (le test de l'itération).

Sémantique :
Identique à celle du pascal (instruction algorithmique tantque .. faire .. ftant) avec le même défaut de fermeture de la boucle.
 

Exemple de boucle while

Pascal-Delphi	C#
while  Expr  do Instr	while ( Expr ) Instr ;
while  Expr  do begin     InstrA ;    InstrB ; ... end	while ( Expr ) {     InstrA ;     InstrB ; ... }

 

4.2.Itération do...while

Syntaxe :

Où expression est une expression renvoyant une valeur booléenne (le test de l'itération).

Sémantique :
"do Instr while ( Expr )" fonctionne comme l'instruction algorithmique répéter  Instr  jusquà non Expr.

Sa sémantique peut aussi être expliquée à l'aide d'une autre instruction C# , le  while( ) :

do Instr while ( Expr ) º  Instr ; while ( Expr ) Instr

Exemple de boucle do...while

Pascal-Delphi	C#
repeat    InstrA ;    InstrB ; ... until not Expr	do {     InstrA ;     InstrB ; ... } while ( Expr )

 

4.3.Itération for

Syntaxe :

Sémantique :
Une boucle for contient 3 expressions for (Expr1 ; Expr2 ; Expr3 ) Instr, d'une manière générale chacune de ces expressions joue un rôle différent dans l'instruction for. Une instruction for en C# (comme en Java) est plus puissante et plus riche qu'une boucle for dans d'autres langages algorithmiques. Nous donnons ci-après une sémantique minimale :
 

• Expr1 sert à initialiser une ou plusieurs variables (dont éventuellement la variable de contrôle de la boucle) sous forme d'une liste d'instructions d'initialisation séparées par des virgules.

• Expr2 sert à donner la condition de rebouclage sous la fome d'une expression renvoyant une valeur booléenne (le test de l'itération).

• Expr3 sert à réactualiser les variables (dont éventuellement la variable de contrôle de la boucle)sous forme d'une liste d'instructions séparées par des virgules.

"for (Expr1 ; Expr2 ; Expr3 ) Instr" fonctionne au minimum comme l'instruction algorithmique pour... fpour.

Sa sémantique peut aussi être approximativement(*) expliquée à l'aide d'une autre instruction C#  while :

for (Expr1 ; Expr2 ; Expr3 ) Instr ;

Expr1 ;  while ( Expr2 )  { Instr ;    Expr3 }

(*)Nous verrons au paragraphe consacré à l'instruction continue que si l'instruction for contient un continue cette définition sémantique n'est pas valide.
 

Exemples montrant la puissance du for

Pascal-Delphi	C#
for i:=1 to 10 do begin    InstrA ;    InstrB ; ... end	for ( i = 1; i<=10; i++ ) {     InstrA ;     InstrB ; ... }
i := 10; k := i; while (i>-450) do begin   InstrA ;   InstrB ; ...   k := k+i;   i := i-15; end	for ( i = 10, k = i ;i>-450 ; k += i ,  i -= 15) {     InstrA ;     InstrB ; ... }
i := n; while i<>1 do   if i mod 2 = 0 then i := i div 2   else i := i+1	for ( i = n ;i !=1 ; i % 2 == 0 ? i /=2 : i++);  // pas de corps de boucle !

• Le premier exemple montre une boucle for classique avec la variable de contrôle "i" (indice de boucle), sa borne initiale "i=1" et sa borne finale "10", le pas d'incrémentation séquentiel étant de 1.

• Le second exemple montre une boucle toujours contrôlée par une variable "i", mais dont le pas de décrémentation séquentiel est de -15.

• Le troisème exemple montre  une boucle aussi contrôlée par une variable "i", mais dont la variation n'est pas séquentielle puisque la valeur de i est modifiée selon sa parité ( i % 2 == 0 ? i /=2 : i++).

Montrons  exemple de boucle for dite boucle infinie :

for ( ; ; );   est équivalente à  while (true);

Voici une boucle ne possédant pas de variable de contrôle(f(x) est une fonction déjà déclarée) :

for (int n=0 ; Math.abs(x-y) < eps ; x = f(x) );

Terminons par une boucle for possédant deux variables de contrôle :

//inverse d'une suite de caractère dans un tableau par permutation des deux extrêmes char [ ] Tablecar ={'a','b','c','d','e','f'} ; for ( i = 0 , j = 5 ;  i<j ; i++ , j-- ) { char car ;    car = Tablecar[i];    Tablecar[i ]= Tablecar[j];    Tablecar[j] = car;   }

dans cette dernière boucle ce sont les variations de i et de j qui contrôlent la boucle.
 
 

Remarques récapitulatives sur la boucle for en C#  :

• rien n'oblige à incrémenter ou décrémenter la variable de contrôle,
• rien n'oblige à avoir une instruction à exécuter (corps de boucle),
• rien n'oblige à avoir une variable de contrôle,
• rien n'oblige à n'avoir qu'une seule variable de contrôle,

5.1.Interruption break

Syntaxe  :

Sémantique :
Une instruction break ne peut se situer qu'à l'intérieur du corps d'instruction d'un bloc switch (le switch est traité au paragraphe suivant), ou de l'une des trois itérations while, do..while, for.

Lorsque break est présente dans l'une des trois itération while, do..while, for :
 

• Si break n'est pas suivi d'une étiquette elle interrompt l'exécution de la boucle dans laquelle elle se trouve, l'exécution se poursuit après le corps d'instruction.
• Si break est suivi d'une étiquette elle fonctionne comme un goto (utilisation déconseillée en programmation moderne sauf pour le switch, c'est pourquoi nous n'en dirons pas plus pour les boucles !)

Exemple d'utilisation du break dans un for :
(recherche séquentielle dans un tableau)

int [ ] table= {12,-5,7,8,-6,6,4,78,2};    int elt = 4;    for ( i = 0 ; i<8 ; i++ )      if (elt= =table[i]) break ;    if (i = = 8)System.out.println("valeur : "+elt+" pas trouvée.");    else System.out.println("valeur : "+elt+" trouvée au rang :"+i);

 

Explications

5.2.Rebouclage continue

Syntaxe  :

Sémantique :
Une instruction continue ne peut se situer qu'à l'intérieur du corps d'instruction de l'une des trois itérations while, do..while, for.

Lorsque continue est présente dans l'une des trois itération while, do..while, for :
 

• Si continue n'est pas suivi d'une étiquette elle interrompt l'exécution de la séquence des instructions situées après elle, l'exécution se poursuit par rebouclage de la boucle. Elle agit comme si l'on venait d'exécuter la dernière instruction du corps de la boucle.
• Si continue est suivi d'une étiquette elle fonctionne comme un goto (utilisation déconseillée en programmation moderne, c'est pourquoi nous n'en dirons pas plus !)

Exemple d'utilisation du continue dans un for :

Rappelons qu'un for s'écrit généralement  :  for (Expr1 ; Expr2 ; Expr3 ) Instr L'instruction continue présente dans une telle boucle for s'effectue ainsi : exécution immédiate de Expr3 ensuite, exécution de Expr2 réexécution du corps de boucle. int [ ] ta = {12,-5,7,8,-6,6,4,78,2}, tb = new int[8]; for ( i = 0, n = 0 ; i<8 ;  i++ , k = 2*n ) { if ( ta[i] = = 0 ) continue ;   tb[n] = ta[i];   n++; }

 

Explications

Si l'expression ( ta[i] = = 0 ) est true, la suite du corps des instructions de la boucle (tb[n] = ta[i];  n++;) n'est pas exécutée et il y a rebouclage du for .

Le déroulement est alors le suivant :

• i++ , k = 2*n en premier ,
• puis la condition de rebouclage : i<8

et la boucle se poursuit en fonction de la valeur de la condition de rebouclage.

Cette boucle recopie dans le tableau d'entiers tb les valeurs non nulles du tableau d'entiers ta.

Attention
Nous avons déjà signalé plus haut que  l'équivalence suivante entre un for et un while

for (Expr1 ; Expr2 ; Expr3 ) Instr º

Expr1 ;  while ( Expr2 )  { Instr ;    Expr3 }

valide dans le cas général, était mise en défaut si le corps d'instruction contenait un continue.

Voyons ce qu'il en est en reprenant l'exemple précédent. Essayons d'écrire la boucle while qui lui serait équivalente selon la définition générale. Voici ce que l'on obtiendrait :

for ( i = 0, n = 0 ; i<8 ;  i++ , k = 2*n ) { if ( ta[i] = = 0 ) continue ;   tb[n] = ta[i];   n++; }

i = 0; n = 0 ;  while ( i<8 )  { if ( ta[i] = = 0 ) continue ;    tb[n] = ta[i];    n++;    i++ ; k = 2*n; }

Dans le while le continue réexécute la condition de rebouclage i<8 sans exécuter l'expression  i++ ; k = 2*n; (nous avons d'ailleurs ici une boucle infinie). Une boucle while équivalente au for précédent pourrait être la suivante :

for ( i = 0, n = 0 ; i<8 ;  i++ , k = 2*n ) { if ( ta[i] = = 0 ) continue ;   tb[n] = ta[i];   n++; }

i = 0; n = 0 ;   while ( i<8 )  { if ( ta[i] = = 0 )   {  i++ ; k = 2*n;      continue ;    }    tb[n] = ta[i];    n++; }

Syntaxe  :

bloc switch :

Sémantique :

 
Cette instruction en C#, contrairement à Java, est structurée , elle doit obligatoirement être utilisée avec l'instruction break afin de simuler le comportement de l'instruction structurée case..of du pascal.

 Exemple de switch..case..break

Pascal-Delphi	C#
var x : char ; .... case x of  'a' : InstrA;  'b' : InstrB;  else InstrElse end;	char x ; .... switch (x) {     case 'a' : InstrA ; break;     case 'b' : InstrB ; break;     default : InstrElse; }

Dans ce cas le déroulement de l'instruction switch après déroutement vers le bon case, est interrompu par le break qui renvoie la suite après la fin du bloc switch. Une telle utilisation correspond à une utilisation de if...else imbriqués (donc utilisation structurée) mais devient plus lisible que les if ..else imbriqués, elle est donc fortement conseillée dans ce cas.

Exemples :

C#  - source	Résultats de l'exécution
int  x = 10; switch (x+1)    { case 11 : System.out.println(">> case 11");                      break;       case 12 : System.out.println(">> case 12");                       break;       default : System.out.println(">> default");     }	>> case 11
int  x = 11; switch (x+1)    { case 11 : System.out.println(">> case 11");                      break;       case 12 : System.out.println(">> case 12");                       break;       default : System.out.println(">> default");     }	>> case 12

Il est toujours possible d'utiliser des instructions if … else imbriquées pour représenter un switch avec break.

Programmes équivalents switch et if...else :

C#  - switch	C#  - if...else
int  x = 10; switch (x+1)    { case 11 : System.out.println(">> case 11");                      break;       case 12 : System.out.println(">> case 12");                       break;       default : System.out.println(">> default");     }	int  x = 10; if (x+1= = 11)System.out.println(">> case 11"); else if (x+1= = 12)System.out.println(">> case 12"); else System.out.println(">> default");

Nous reviendrons plus loin sur les exceptions et l'instruction try..catch. Nous donnons ici la syntaxe d'une version simple et nous indiquons que sa sémantique est semblable à celle du bloc try..except de Delphi. Sachons pour l'instant que C# dispose d'un mécanisme puissant identique à Java, présent dans les langages robustes Ada, C++, Delphi pour intercepter et traiter les erreurs ou incidents survenant dans un bloc d'instruction.

L'instruction try...catch sert à traiter de tels incidents, elle dispose d'un bloc try (pour les instructions à protéger)et d'un ou plusieurs blocs catch (pour divers genres de traitement en cas d'incidents).

try {
   BLOC à protéger
  }
   catch (TypeErreur1  Err1) {
      TRAITEMENT d'une erreur du type TypeErreur1
  }
catch (TypeErreur2  Err2) {
      TRAITEMENT d'une erreur du type TypeErreur2
  }
...
catch (TypeErreurX  ErrX) {
      TRAITEMENT d'une erreur du type TypeErreurX
  }

Ci-dessous une exemple permettant d'intercepter une erreur dans la division de l'entier x par l'entier y :

Exemple de try...catch

Pascal-Delphi	C#
var x , y : integer; try  x := 1;  y := 0;  Memo.lines.add("division ="+x div y); except   on Err : EIntError do begin    Memo.lines.add("Calcul impossible.");    Memo.lines.add(Err.message);   end end;	int x , y ; try {     x = 1;     y = 0;    System.Console.WriteLine( "division ="+x/y);   }  catch (ArithmeticException Err) {    System.Console.WriteLine("Calcul impossible.");    System.Console.WriteLine(Err.getMessage());   }