Le language C# est un langage de programmation structuré.
La structure d'un programme définit l'ordre d'exécution des instructions : condition, boucles, ...
Condition.
Une instruction peut s'exécuter lorsqu'une condition est vraie. La syntaxe est la suivante :
 if ("expression")
 "instruction"
codice_1 définit la condition et doit être du type codice_2, c'est-à-dire qu'elle ne peut valoir que codice_3 (vrai) ou codice_4 (faux).
L'instruction n'est exécutée que si la condition est vraie (codice_3).
Exemple :
if (a==10) Console.WriteLine("a vaut 10");
Plusieurs instructions.
Pour exécuter plusieurs instructions si la condition est vraie, codice_6 peut être remplacé par un bloc d'instructions entre accolades :
 "instruction"
 "instruction"
Exemple :
if (a==10)
 Console.WriteLine("a vaut 10");
 a=9;
 Console.WriteLine("désormais a vaut 9");
Sinon....
Il est possible d'exécuter des instructions quand une condition est vraie, et d'autres instructions quand elle est fausse.
La syntaxe est la suivante :
 if ("expression")
 "instruction"
 else
 "instruction"
Exemples :
if (a==10) Console.WriteLine("a vaut 10");
else Console.WriteLine("a ne vaut pas 10");
if ((a==10)&&(b==11)) Console.WriteLine("a vaut 10 et b vaut 11");
else Console.WriteLine("a ne vaut pas 10 ou b ne vaut pas 11");
Conditions multiples.
L'enchaînement des instructions conditionnelles est possible.
Exemple :
if (a==10)
 if (b==11) Console.WriteLine("a vaut 10 et b vaut 11");
 else Console.WriteLine("a vaut 10 mais b ne vaut pas 11");
else Console.WriteLine("a ne vaut pas 10");
Chaque instruction codice_7 correspond au codice_8 qui le précède, s'il n'a pas déjà de codice_7.
Cependant, pour clarifier le code ou résoudre certains cas ambigus (pas de codice_7 pour le second codice_8, par exemple), il est préférable de mettre des accolades :
if (a==10)
 if (b==11) Console.WriteLine("a vaut 10 et b vaut 11");
 else Console.WriteLine("a vaut 10 mais b ne vaut pas 11");
else Console.WriteLine("a ne vaut pas 10");
Autre exemple :
if (a==10) Console.WriteLine("a vaut 10");
else if (a==11) Console.WriteLine("a vaut 11");
else Console.WriteLine("a ne vaut ni 10, ni 11");
Dans cet exemple, chaque instruction codice_8 n'est testée que si la précédente est fausse.
Si le nombre de cas est important et que chaque condition teste une valeur pour la même expression, il est préférable d'utiliser l'instruction codice_13.
Tests de plusieurs cas.
L'instruction codice_13 permet de tester la valeur d'une expression avec plusieurs cas.
La syntaxe est la suivante :
 switch("expression")
 "cas" :
 "cas" :
 "instructions"
 "fin du cas"
 "cas" :
 "cas" :
 "instructions"
 "fin du cas"
 "..."
Où "cas" peut avoir l'une des deux syntaxes suivantes :
"fin du cas" est une instruction spéciale terminant le ou les cas. Hormis les instructions interrompant le cours de l'exécution (une instruction interrompant ou continuant une boucle, une instruction codice_17 pour lancer une exception, une instruction codice_18), il s'agit en général de l'une des deux instructions suivantes :
Exemple :
switch(a)
case 10 :
 Console.WriteLine("a vaut 10");
 break;
case 11 :
 Console.WriteLine("a vaut 11");
 break;
default :
 Console.WriteLine("a ne vaut ni 10, ni 11");
 break;
La syntaxe permet de rassembler plusieurs cas ensemble pour exécuter les mêmes instructions :
switch(a)
case 2 :
case 3 :
case 5 :
 Console.WriteLine("a vaut 2, 3 ou 5");
 break;
case 10 :
case 11 :
 Console.WriteLine("a vaut 10 ou 11");
 break;
default :
 Console.WriteLine("a n'est pas dans la liste (2, 3, 5, 10, 11)");
 break;
Il est également possible de poursuivre le traitement avec les instructions d'un autre cas :
switch(a)
case 10 :
 Console.WriteLine("a vaut 10");
 goto case 11;
case 11 :
 Console.WriteLine("a vaut "+a);
 break;
default :
 Console.WriteLine("a ne vaut ni 10, ni 11");
 break;
Selon le type d'un objet.
Le test avec un objet permet de tester des cas représentant un sous-type de sa classe.
Exemple pour traiter différemment les sous-classes de la classe Meuble (Armoire, Commode, Table, Chaise, Lit) :
void UtiliserMeuble(Meuble m)
 switch(m)
 armoire.ranger();
 break;
 lit.dormir();
 break;
 case null:
 // ne rien faire sans meuble
 break;
 default: // autre type de meuble
 m.utiliser();
 break;
Cas conditionnels.
Depuis C# 7.0, il est possible d'ajout une clause codice_22 aux cas pour définir une condition.
Le même cas peut apparaitre plusieurs fois avec des conditions différentes.
void UtiliserMeuble(Meuble m)
 switch(m)
 case Armoire armoire when armoire.EstPleine() :
 armoire.vider();
 break;
 case Armoire armoire:
 armoire.ranger();
 break;
 case Lit lit when lit.EstLibre():
 lit.dormir();
 break;
 case null:
 // ne rien faire sans meuble
 break;
 default: // autre type de meuble
 m.utiliser();
 break;
Boucles.
Une boucle permet d'exécuter plusieurs fois une ou des instructions tant qu'une condition est vraie.
Boucle while.
La boucle codice_23 est la plus simple : tant que la condition est vraie, elle exécute l'instruction ou le bloc d'instructions spécifié.
Sa syntaxe est la suivante :
 while ( "expression" )
 "instruction_ou_bloc"
Où "expression" est une expression du type codice_2, c'est-à-dire valant codice_3 (vrai) ou codice_4 (faux).
Exemple : rechercher une valeur spécifique dans un tableau d'entiers
int i = 0;
// tant que i est un indice correct et que la valeur 0 n'est pas trouvée
while ( (i < tableau.Length ) && ( tableau[i] != 0 ) )
 Console.WriteLine(tableau[i]);
 i++;
N.B.: Si la condition est fausse dès le début, l'instruction ou le bloc n'est pas exécuté, car la condition est testée avant.
Boucle do...while.
La boucle codice_27 ressemble à la précédente, excepté que la condition est testée après. C'est-à-dire que le bloc d'instructions est toujours exécuté au moins une fois.
La syntaxe est la suivante :
 do
 "instructions"
 while ( "expression" );
Où "expression" est une expression de type codice_2.
Exemple :
string fichier;
do
 Console.Write("Entrez un nom de fichier ou rien pour quitter : ");
 fichier=Console.ReadLine();
 if (fichier != "") TraiterFichier(fichier);
while ( fichier != "" );
Boucle for.
La boucle codice_29 regroupe plusieurs phases de la boucle :
La syntaxe d'une boucle codice_29 est la suivante :
 for ( "initialisation" ; "condition" ; "incrémentation" )
 "instructions"
Exemple : afficher tous les éléments d'un tableau d'entiers jusqu'à trouver un zéro.
for ( int i=0 ; (i<tableau.Length)&&(tableau[i]!=0) ; i++ )
 Console.WriteLine( tableau[i] );
Boucle foreach.
La boucle codice_31 parcours tous les éléments d'un objet implémentant l'interface codice_32. Il s'agit d'une version simplifiée de la boucle codice_29.
La syntaxe est la suivante :
 foreach ( "type variable" in "objet_IEnumerable")
 "instructions"
Durant la boucle, la variable "variable" (de type "type") vaut successivement toutes les valeurs retournées par l'objet implémentant l'interface codice_32.
Les tableaux implémentent cette interface, et peuvent donc être utilisés dans une boucle codice_31.
Exemple : afficher tous les éléments d'un tableau
string[] messages = { "Test", "d'une", "boucle foreach" };
foreach ( string s in messages )
 Console.WriteLine(s);
Interrompre une boucle.
L'instruction codice_36 permet d'interrompre prématurément une boucle.
Syntaxe :
break;
Exemple :
for(int i = 0 ; i < 10 ; i++)
 Console.WriteLine( "i vaut " + i );
 if (i==5) break; // Arrêter à 5
Le code ci-dessus affiche :
 i vaut 0
 i vaut 1
 i vaut 2
 i vaut 3
 i vaut 4
 i vaut 5
Continuer une boucle.
L'instruction codice_37 permet de poursuivre une boucle, c'est-à-dire passer immédiatement à l'itération suivante sans exécuter les autres instructions de la boucle.
Syntaxe :
continue;
Exemple :
for(int i = 0 ; i < 10 ; i++)
 if (i==5) continue; // Sauter 5
 Console.WriteLine( "i vaut " + i );
Le code ci-dessus affiche :
 i vaut 0
 i vaut 1
 i vaut 2
 i vaut 3
 i vaut 4
 i vaut 6
 i vaut 7
 i vaut 8
 i vaut 9
L'interface codice_32 et le mot clé codice_39.
L'interface IEnumerable est définie dans deux espaces de nom différents :
Comme la plupart des classes de ces deux espaces de nom, ces deux classes ne diffèrent que par le type utilisé pour chaque élément : codice_41 ou générique. L'interface IEnumerable ne définit qu'une seule méthode :
IEnumerator GetEnumerator();
IEnumerator<T> GetEnumerator();
L'implémentation d'une fonction retournant une instance de l'interface codice_46 est simplifiée en utilisant le mot clé codice_39.
Celui-ci est utilisé pour retourner chaque élément de l'itération ou pour interrompre l'itération :
Exemple :
using System.Collections.Generic;
public class Mots
 // Tableau contenant des mots :
 public string[] mots;
 // Constructeur
 public Mots(params string[] mots)
 // Énumérer tous les mots jusqu'à trouver
 // le mot contenu dans le paramètre dernier (exclu)
 // ou la fin du tableau.
 public IEnumerable<string> TousLesMotsJusquA(string dernier)
 foreach(string mot in mots)
 if (mot.Equals(dernier)) yield break; // fin prématurée de l'itération
 else yield return mot; // élément de l'itération
 // fin normale de la boucle d'itération
public class TestProgram
 public static void Main()
 Mots fruits = new Mots( "pomme", "poire", "abricot", "fraise", "kiwi" );
 foreach( string fruit in fruits.TousLesMotsJusquA("fraise") )
 Console.WriteLine( fruit );
Ce programme affiche :
 pomme
 poire
 abricot
Les fruits suivants ne sont pas affichés car le mot "fraise" a été trouvé.