UPRECO

Notes de
cours de
C#
Par Ir Joseph MUAMBA
Ass1
Année académique
2023-2024

0. INTRODUCTION

CHAPITRE I : CREATION D’UN PROJET AVEC VISUAL

STUDIO 2012

CHAPITRE II : SYNTHAXE GENERAL DE C#

CHAPITRE II : PROGRAMMATION EN MODE GRAPHIQUE

CHAPITRE IV : ACCES AUX BASES DE DONNEES

CHAPITRE V : ETUDE DES CAS

INTRODUCTION

Il existe beaucoup de langages de programmation, comme le C, le

C++, Python, Java... Chacun a ses avantages, ses inconvénients et
ses domaines d'applications.

Le C# (Prononcez "Cé charpe" ou "ci charpe" à l'anglaise), est un

langage de programmation créé par Microsoft en 2002.

Le C# est un langage dont la syntaxe ressemble un peu au C++

ou au Java qui sont d’autres langages de programmation très
populaires. Le C# est le langage phare de Microsoft. Il fait partie
d’un ensemble plus important.

Création des programmes

Avec des langages traditionnels comme le C et le C++, on écrit des

instructions simplifiées, lisibles par un humain comme :

Code : C

printf ("Bonjour" );

Ce n'est pas vraiment du français, mais c'est quand même beaucoup

plus simple que le binaire et on comprend globalement avec cet
exemple que l'on va afficher le mot Bonjour.
Bien entendu, l'ordinateur ne comprend pas ces instructions. Lui, il
veut du binaire, du vrai.
Pour obtenir du binaire à partir d'un code écrit en C ou C++, on doit
effectuer ce qu'on appelle une compilation. Le compilateur est un
programme qui traduit le code source en binaire exécutable :
Cette méthode est efficace. De nombreuses personnes développent
toujours en C et C++ aujourd'hui.
Néanmoins, ces langages ont aussi un certain nombre de défauts
dus à leur ancienneté. Par exemple, un programme compilé
(binaire) ne fonctionne que sur la plateforme pour laquelle il a été
compilé. Cela veut dire que si vous compilez sous Windows, vous
obtenez un programme qui fonctionne sous Windows uniquement
(et sur un type de processeur particulier). Impossible de le faire
tourner sous Mac OS X ou Linux simplement, à moins de le
recompiler sous ces systèmes d'exploitation (et d'effectuer au
passage quelques modifications).

Les programmes binaires ont ce défaut : ils ne fonctionnent que pour

un type de machine. Pour les développeurs qui écrivent le code,
c'est assez fastidieux à gérer.

Les langages récents, comme le C# et le Java, résolvent ce

problème de compatibilité tout en ajoutant de nombreuses
fonctionnalités appréciables au langage, ce qui permet de réaliser
des programmes beaucoup plus efficacement.

La compilation en C# ne donne pas un programme binaire,

contrairement au C et au C++. Le code C# est en fait transformé
dans un langage intermédiaire (appelé CIL ou MSIL) que l'on peut
ensuite distribuer à tout le monde. Ce code, bien sûr, n'est pas
exécutable lui-même, car l'ordinateur ne comprend que le binaire.

Regardez bien ce schéma pour comprendre comment cela

fonctionne :
Le code en langage intermédiaire (CIL : Common Intermediate
Language) correspond au programme que vous allez distribuer. Sous
Windows, il prend l'apparence d'un .exe comme les programmes
habituels, mais il ne contient en revanche pas de binaire.

Lorsqu'on exécute le programme CIL, celui-ci est lu par un autre

programme (une machine à analyser les programmes, appelée CLR)
qui le compile cette fois en vrai programme binaire. Cette fois, le
programme peut s'exécuter. Cela offre beaucoup de souplesse au
développeur. Le code en langage intermédiaire (CIL) peut être
distribué à tout le monde. Il suffit d'avoir installé la machine CLR
(Common Language Runtime) sur son ordinateur, qui peut alors lire
les programmes en C# et les compiler "à la volée" en binaire.
Avantage : le programme est toujours adapté à l'ordinateur sur
lequel il tourne.

La CLR vérifie aussi la sécurité du code ; ainsi en C du code mal

pensé (par exemple une mauvaise utilisation des pointeurs) peut
entraîner des problèmes pour votre PC, ce que vous risquez
beaucoup moins avec le C#. De plus, la CLR dispose du JIT debugger
qui permet de lancer Visual Studio si une erreur survient dans un
programme .NET pour voir ce qui a causé cette erreur. On parle de
code managé.

Cette complexité ralentit légèrement la vitesse d'exécution des

programmes (par rapport au C ou au C++), mais la différence est
aujourd'hui vraiment négligeable par rapport aux gains que cela
apporte.

Donc, en théorie, il est possible d'utiliser n'importe quelle application

compilée en langage intermédiaire à partir du moment où il y a une
implémentation du CLR disponible.
En réalité, il n'y a que sous Windows qu'il existe une implémentation
complète du CLR. Il existe cependant une implémentation partielle
sous Linux : Mono. Cela veut dire que si votre programme utilise des
fonctionnalités qui ne sont pas couvertes par Mono, il ne
fonctionnera pas.
Exécutables et assemblages
Nous avons vu au dessus que le C# était compilé en langage
intermédiaire et qu'on le retrouve sous la forme d'un .exe comme les
programmes habituels.
Par contre, c'est un peu incomplet.

Il est possible de créer des programmes (.exe) qui pourront

directement être exécuté par le CLR, mais il est également possible
de créer des bibliothèques sous la forme d'un fichier possédant
l'extension « .dll ».

On appelle ces deux formes de programmes des assemblages, mais

on utilise globalement toujours le mot anglais « assembly ».

Les fichiers .exe sont des assemblys de processus

Les fichiers .dll sont des assemblys de bibliothèques

Concrètement, cela signifie que le fichier .exe servira à lancer une

application et qu'une dll pourra être partagée entre plusieurs
applications .exe afin de réutiliser du code déjà écrit.

Le Framework .NET

Un framework est une espèce de grosse boite à fonctionnalités

qui permet de réaliser des applications informatiques de toutes
sortes. En fait, c’est la combinaison de ce framework et du langage
de programmation C# qui va nous permettre de réaliser ces
applications informatiques.

Le framework .NET est un framework créé par Microsoft en 2002,

en même temps que le C#, qui est principalement dédié à la
réalisation d’applications fonctionnant dans des environnements
Microsoft. Nous pourrons par exemple réaliser des programmes qui
fonctionnent sous Windows, ou bien des sites web ou encore des
applications qui fonctionnent sur téléphone mobile, etc.

Disons que la réalisation d’une application informatique, c’est un peu

comme un chantier. Il est possible de construire différentes choses,
comme une maison, une piscine, une terrasse, etc. Pour réaliser ces
constructions, nous allons avoir besoin de matériaux, comme des
briques, de la ferraille, etc. Certains matériaux sont communs à
toutes les constructions (fer, vis, …) et d’autres sont spécifiques à
certains domaines (pour construire une piscine, je vais avoir besoin
d’un liner par exemple).

On peut voir le framework .NET comme ces matériaux, c’est un

ensemble de composants que l’on devra assembler pour réaliser
notre application. Certains sont spécifiques pour la réalisation
d’applications web, d’autres pour la réalisation d’applications
Windows, etc.

Pour réaliser un chantier, nous allons avoir besoin d’outils pour

manipuler les matériaux. Qui envisagerait de visser une vis avec les
doigts ou de poser des parpaings sans les coller avec du mortier ?
C’est la même chose pour une application informatique, pour
assembler notre application, nous allons utiliser un langage de
programmation : le C#.

De nos jours, le C# est en version 12 ainsi que le framework .NET 4.

Ce sont des versions stables et utilisées par beaucoup de personnes.
Chaque version intermédiaire a apporté son lot d’évolutions. Le
framework .NET et le C# sont en perpétuelle évolution preuve de la
dynamique apportée par Microsoft.

En résumé

 Le C# est un langage de programmation permettant d’utiliser

le framework .NET. C’est le langage phare de Microsoft.
 Le framework .NET est une énorme boîte à fonctionnalités
permettant la création d’applications.
 Le C# permet de développer des applications de toutes sortes,
exécutables par le CLR qui traduit le MSIL (MicroSoft
Intermediate language) binaire.
 Il est possible de créer des assemblys de deux sortes : des
assemblys de processus exécutables par le CLR et des
assemblys de bibliothèques.
Chap. 2 : La syntaxe générale du C#
Nous allons aborder ici la syntaxe générale du langage de
programmation C# dans le cadre d’une application console. Il est en
effet possible de créer plein de choses différentes avec le C# comme
une application web, des jeux, etc.

Dans cette optique, nous allons utiliser très souvent l’instruction :

Console.WriteLine("…"); que nous avons vue au chapitre
précédent et qui est une instruction dédiée à l’affichage sur la
console. C’est une instruction qui va s’avérer très pratique pour
notre apprentissage car nous pourrons avoir une représentation
visuelle de ce que nous allons apprendre. Il est globalement rare
qu’une application ne doive afficher que du texte, sans aucune
mise en forme. Vous verrez en fin du cours comment réaliser des
applications un peu plus évoluées graphiquement.

Ecrire une ligne de code

Les lignes de code écrites avec le langage de développement C#
doivent s’écrire dans des fichiers dont l’extension est .cs. Nous
avons vu dans le chapitre précédent que nous avons écrit dans le
fichier Program.cs qui est le fichier qui a été généré par Visual
studio lors de la création du projet. Nous y avons notamment
rajouté une instruction permettant d’afficher du texte.
Les lignes de code C# se lisent et s’écrivent de haut en
bas et de gauche à droite, comme un livre normal. Aussi,
une instruction écrite avant une autre sera en général
exécutée avant celle-ci.

Attention, chaque ligne de code doit être correcte

syntaxiquement sinon le compilateur ne saura pas le
traduire en langage exécutable.

Par exemple, si à la fin de l’instruction, on retire le point-virgule ou si

j’orthographie mal le mot WriteLine, nous aurons :
Visual Studio signale qu’il y a un problème en mettant en valeur un
manque au niveau de la fin de l’instruction et il souligne également
le mot « WritLine ».
Dans la fenêtre du bas, il indique qu’il a deux erreurs et donne des
précisions sur celles-ci avec éventuellement des pistes pour
résoudre ces erreurs.

Si on tente de lancer l’application (raccourci ctrl+F5), Visual C#

Express va tenter de compiler et d’exécuter l’application. Ceci
n’étant pas possible, il affichera un message indiquant qu’il y a des
erreurs.

Ce sont des erreurs de compilation qu’il va falloir résoudre si l’on

souhaite que l’application console puisse s’exécuter.

Nous allons voir dans les chapitres suivant comment écrire

correctement des instructions en C#. Mais il est important de noter à
l’heure actuelle que le C# est sensible à la casse, ce qui veut dire
que les majuscules comptent !
Ainsi le mot « WriteLine » et le mot « WriTEline » sont deux mots
bien distincts et peuvent potentiellement représenter deux
instructions différentes. Ici, le deuxième mot est incorrect car il
n’existe pas.
 Le caractère de terminaison de ligne
En général, une instruction en code C# s’écrit sur
une ligne et se termine par un point-virgule.

En général, pour que le code soit le plus lisible possible, on écrit une
instruction par ligne et on indente le code de façon à ce que les
blocs soient lisibles. Un bloc de code est délimité par des accolades
{ et }.
L’instruction "Bonjour" représente une chaine de caractères et est
passée en paramètre de la méthode Console.WriteLine à l’aide des
parenthèses. La chaine de caractères est délimitée par les
guillemets. Enfin, le point-virgule permet d’indiquer que l’instruction
est terminée et qu’on peut enchainer sur la suivante.

Certains points ne sont peut-être pas encore tout à fait clairs,

comme ce qu’est vraiment une méthode, ou comment utiliser des
chaines de caractères, mais ne vous inquiétez pas, nous allons y
revenir plus en détail dans les chapitres suivants et découvrir au
fur et à mesure les arcanes du C#.
Les commentaires
Pour faciliter la compréhension du code ou pour se rappeler un point
précis, il est possible de mettre des commentaires dans son code.
Les commentaires sont ignorés par le compilateur et n’ont qu’une
valeur informative pour le développeur. Dans un fichier de code C#
(.cs), on peut écrire des commentaires de 2 façons différentes :

Soit en commençant son commentaire par /* et en le

terminant par */ ce qui permet d’écrire un commentaire sur
plusieurs lignes.
Soit en utilisant // et tout ce qui se trouve après sur la même ligne
est alors un commentaire.

Visual Studio colore les commentaires en

vert pour faciliter leurs identifications.

Code : C#
 La complétion automatique
Visual C# express est un formidable outil qui nous facilite à tout
moment la tâche, notamment grâce à la complétion automatique.
La complétion automatique est le fait de proposer de compléter
automatiquement ce que nous sommes en train d’écrire en se
basant sur ce que nous avons le droit de faire.
Par exemple, si vous avez cherché à écrire l’instruction :

Code : C#

Console.WriteLine ("Bonjour") ;

Vous avez pu constater que lors de l’appui sur la touche C, Visual

Studio nous affiche une fenêtre avec tout ce qui commence par « C
»:

Au fur et à mesure de la saisie, il affine les propositions pour se

positionner sur la plus pertinente. Il est possible de valider la
proposition en appuyant sur la touche Entrée. Non seulement cela
nous économise des appuis de touches, paresseux comme nous
sommes, mais cela nous permet également de vérifier la syntaxe de
ce que nous écrivons et d’obtenir également une miniaide sur ce
que nous essayons d’utiliser.

Ainsi, finies les fautes de frappe qui résultent en une erreur de

compilation ou les listes de mots clés dont il faut absolument retenir
l’écriture.

De la même façon, une fois que vous avez fini de saisir « Console »
vous allez saisir le point « . » et Visual Studio va nous proposer toute
une série d’instruction en rapport avec le début de l’instruction :
Nous pourrons ainsi facilement finir de saisir « WriteLine » et ceci
sans erreur d’écriture, ni problème de majuscule.

En résumé

 Le code C# est composé d’une suite d’instructions qui se

terminent par un point virgule.
 La syntaxe d’un code C# doit être correcte sinon nous
aurons des erreurs de compilation.
 Il est possible de commenter son code grâce aux caractères
« // », « /* » et « */ ».
 Visual C# Express dispose d’un outil puissant qui permet
d’aider à compléter ses instructions : la complétion
automatique.

Les variables

Comme tous les langages de programmations, le C# va pouvoir

conserver des données grâce à des variables. Ce sont en fait des
blocs de mémoire qui vont contenir des nombres, des chaines de
caractères, des dates ou plein d’autres choses.
On peut les comparer à des petits classeurs possédant une
étiquette. On va pouvoir mettre des choses dans ces classeurs, par
exemple, je mets 30 dans le classeur étiqueté « âge de Joseph » et
20 dans le classeur « âge de Jean ». Si je veux connaitre l’âge de
Moise, je n’ai qu’à regarder dans ce classeur pour obtenir 30. Je
peux également remplacer ce qu’il y a dans mon classeur par
autre chose, par exemple changer 30 en 25. Je ne peux par contre
pas mettre deux choses dans mon classeur, il n’a qu’un seul
emplacement.
Une variable est représentée par son nom, caractérisée par son
type et contient une valeur.
Par exemple, l’âge d’une personne pourrait être stockée sous la
forme d’un entier et accessible par la variable « age », ce qui s’écrit
en C# :

Code : C#
int age;

On appelle ceci « la déclaration de la variable age ».

Le mot clé int permet d’indiquer au compilateur que la variable «

age » est un entier numérique. int correspond au début d’ « integer
» qui veut dire « entier » en anglais.

Ici, la variable « age » n’a pas été initialisée, elle ne pourra pas être
utilisée car le compilateur ne sait pas quelle valeur il y a dans la
variable age.

Pour l’initialiser (on parle également « d’affecter une valeur ») on

utilisera l’opérateur égal (« = »).

Code : C#

int age ;
age = 30;

La variable « age » possède désormais l’entier numérique « 30 »

comme valeur.

L’initialisation d’une variable peut également se faire au même

moment que sa déclaration. Ainsi, on pourra remplacer le code
précédent par :

Code : C#
int age = 30;

Pour déclarer une variable en C#, on commence toujours par

indiquer son type et son nom. Il faudra impérativement affecter une
valeur à cette variable avec l’opérateur « = », soit sur la même
instruction que la déclaration, soit un peu plus loin dans le code,
mais dans tous les cas, avant l’utilisation de cette variable.
Nous pouvons à tout moment demander la valeur contenue dans la
variable age.

Vous pouvez nommer vos variables à peu près n’importe comment,

à quelques détails près. Les noms de variables ne peuvent pas avoir
le même nom qu’un type. Il sera alors impossible d’appeler une
variable int. Il est également impossible d’utiliser des caractères
spéciaux, comme des espaces ou des caractères de ponctuation. De
même, on ne pourra pas nommer une variable en commençant par
des chiffres.

Il est par contre possible d'utiliser des accents dans les noms de
variable, cependant ceci n'est pas recommandé et ne fait pas partie
des bonnes pratiques de développement. En effet, il est souvent
recommandé de nommer ses variables en anglais (langue qui ne
contient pas d'accents).

En général, une variable commence par une minuscule et si son nom

représente plusieurs mots, on démarrera un nouveau mot par une
majuscule. Par exemple : int ageDuVisiteur

C’est ce qu’on appelle le camel case.

Attention, suivant le principe de sensibilité à la casse, il faut faire

attention car ageduvisiteur et ageDuVisiteur seront deux variables
différentes :

A noter un détail qui peut paraitre évident, mais toutes les variables
sont réinitialisées à chaque nouvelle exécution du programme. Dès
qu’on démarre le programme, les classeurs sont vidés, comme si on
emménageait dans des nouveaux locaux à chaque fois. Il est donc
impossible de faire persister une information entre deux exécutions
du programme en utilisant des variables. Pour ceci, on utilisera
d’autres solutions, comme enregistrer des valeurs dans un fichier ou
dans une base de données. Nous y reviendrons ultérieurement.
Les différents types de variables
Nous avons vu juste au-dessus que la variable « age » pouvait être
un entier numérique grâce au mot clé int. Le framework .NET
dispose de beaucoup de types permettant de représenter beaucoup
de choses différentes.

Les principaux types de base du framework .NET sont :

Type Description
byte Entier de 0 à 255
 short Entier de -32768 à 32767
int Entier de -2147483648 à 2147483647
long Entier de -9223372036854775808 à
9223372036854775807
float Nombre simple précision de -3,402823e38 à
3,402823e38
double Nombre double précision de -1,79769313486232e308 à
1,79769313486232e308
Nombre décimal convenant particulièrement aux calculs
decimal financiers (en raison de ses nombres significatifs après
la virgule)
char Représente un caractère
string Une chaine de caractère
bool Une valeur booléenne (vrai ou faux)

Affectations, opérations, concaténation

Il est possible d’effectuer des opérations sur les variables et entre

les variables. Nous avons déjà vu comment affecter une valeur à une
variable grâce à l’opérateur =.
En plus de la simple affectation, nous pouvons également faire des
opérations

Les opérateurs « + », « * », « / » ou encore « - » (que nous

n’avons pas encore utilisé) servent bien évidemment à faire les
opérations mathématiques qui leur correspondent, à savoir
respectivement l’addition, la multiplication, la division et la
soustraction.
Vous aurez donc surement deviné que la variable « resultat »
contient 6 et que la moyenne vaut 25.

Il est à noter que les variables contiennent une valeur qui ne peut
évoluer qu’en affectant une nouvelle valeur à cette variable.

L’opérateur « + » peut également servir à concaténer des chaines

de caractères, par exemple :

Code : C#
D’autres opérateurs particuliers existent que nous ne trouvons pas
dans les cours de mathématiques. Par exemple, l’opérateur ++ qui
permet de réaliser une incrémentation de 1, ou l’opérateur -- qui
permet de faire une décrémentation de 1.

De même, les opérateurs que nous avons déjà vus peuvent se

cumuler à l’opérateur = pour simplifier une opération qui prend une
variable comme opérande et cette même variable comme résultat.
Par exemple :

Code : C#

int age = 20;

age = age + 10; // age contient 30 (addition)
age++; // age contient 31 (incrémentation de 1)
age--; // age contient 30 (décrémentation de 1)
age += 10; // équivalent à age = age + 10 (age contient 40)
age /= 2; // équivalent à age = age / 2 => (age contient 20)

Comme nous avons pu le voir dans nos cours de mathématiques, il

est possible de grouper des opérations avec des parenthèses pour
agir sur leurs priorités.

Ainsi, l’instruction précédemment vue :

Code : C#

int moyenne= (age1 + age2) / 2;

Effectue bien la somme des deux âges avant de les diviser par 2, car
les parenthèses sont prioritaires.

Cependant, l’instruction suivante :

Code : C#

int moyenne = age1 + age2 / 2;

aurait commencé par diviser l’age2 par 2 et aurait ajouté l’age1, ce

qui n’aurait plus rien à voir avec une moyenne. En effet, la division
est prioritaire par rapport à l’addition.
Oui et non.
Si nous divisions 5 par 2, nous obtenons bien 2.5.
Par contre, ici nous divisons l'entier 5 par l'entier 2 et nous stockons
le résultat dans l'entier moyenne. Le C# réalise en fait une division
entière, c'est-à-dire qu'il prend la partie entière de 2.5, c'est-à-dire
2.

De plus, l'entier moyenne est incapable de stocker une valeur

contenant des chiffres après la virgule. Il ne prendrait que la partie
entière.

Les caractères spéciaux dans les chaines de caractères

En ce qui concerne l’affectation de chaines de caractères, vous
risquez d’avoir des surprises si vous tentez de mettre des caractères
spéciaux dans des variables de type string.
En effet, une chaine de caractères étant délimitée par des guillemets
" ", comment faire pour que notre chaine de caractères puisse
contenir des guillemets ?

C’est là qu’intervient le caractère spécial \ qui sera à mettre juste

devant le guillemet, par exemple le code suivant :

Code : C#

string phrase = "Mon prénom est \"Nicolas\"" ;

Console .WriteLine (phrase );

affichera :

Si vous avez testé par vous-même l’instruction Console.WriteLine et

enchainé plusieurs instructions qui écrivent des lignes, vous avez pu
remarquer que nous passions à la ligne à chaque fois. C’est le rôle
de l’instruction WriteLine qui affiche la chaine de caractères et passe
à la ligne à la fin de la chaîne de caractères.

Nous pouvons faire la même chose en utilisant le caractère spécial

« \n ». Il permet de passer à la ligne à chaque fois qu’il est
rencontré.
Ainsi, le code suivant :

Code : C#

string phrase = "Mon prénom est \"Nicolas\"";

Console.WriteLine(phrase);
Console.WriteLine("Passe\nà\nla\nligne\n\n\n");

affichera :

où nous remarquons bien les divers passages à la ligne.

Vous me diriez qu’on pourrait enchaîner les Console.WriteLine et
vous auriez raison.

Mais les caractères spéciaux nous permettent de faire d’autres

choses comme une tabulation par exemple grâce au caractère
spécial « \t ». Le code suivant :

Code : C#

);
Console.WriteLine("Choses à faire :"
Console.WriteLine("\t - Arroser les plantes"
);
Console.WriteLine("\t - Laver la voiture"
);
permettra d’afficher des tabulations, comme illustré ci-dessous :

Les opérateurs de comparaison

Une condition se construit grâce à des opérateurs de
comparaison. On dénombre plusieurs opérateurs de comparaisons,
les plus courants sont :
Opéra
Description
teur
== Egalité
!= Différen
ce
> Supérie
ur à
< Inférieu
rà
>= Supérie
ur ou
égal
<= Inférieu
r ou
égal
&& ET
logique
|| OU
logique
! Négatio
n
Les conversions entre nombres et chaînes de caractères

nombre -> chaîne nombre.ToString()

chaine -> int int.Parse(chaine)

chaîne -> long long.Parse(chaine)

chaîne -> double double.Parse(chaîne)

chaîne -> float float.Parse(chaîne)

La conversion d'une chaîne vers un nombre peut échouer si la

chaîne ne représente pas un nombre valide. Il y a alors génération
d'une erreur fatale appelée exception. Cette erreur peut être gérée
par la clause try/catch suivante :

try{
appel de la fonction susceptible de générer l'exception
} catch (Exception e){
traiter l'exception e
}
instruction suivante

Si la fonction ne génère pas d'exception, on passe alors à

instruction suivante, sinon on passe dans le corps de la clause catch
puis à instruction suivante. Nous reviendrons ultérieurement sur la
gestion des exceptions. Voici un programme présentant quelques
techniques de conversion entre nombres et chaînes de caractères.

Les tableaux de données

Un tableau C# est un objet permettant de rassembler sous un
même identificateur des données de même type. Sa déclaration est
la suivante :

Type[] tableau[]=new Type[n]

n est le nombre de données que peut contenir le tableau. La syntaxe

Tableau[i] désigne la donnée n° i où i appartient à l'intervalle [0,n-1].
Toute référence à la donnée Tableau[i] où i n'appartient pas à
l'intervalle [0,n-1] provoquera une exception. Un tableau peut être
initialisé en même temps que déclaré :

int[] entiers=new int[] {0,10,20,30};

ou plus simplement :

int[] entiers={0,10,20,30};

Les tableaux ont une propriété Length qui est le nombre

d'éléments du tableau.

Un tableau à deux dimensions pourra être déclaré comme suit :

Type[,] tableau=new Type[n,m];

où n est le nombre de lignes, m le nombre de colonnes. La syntaxe

Tableau[i,j] désigne l'élément j de la ligne i de tableau. Le tableau à
deux dimensions peut lui aussi être initialisé en même temps qu'il
est déclaré :

double[,] réels=new double[,] { {0.5, 1.7}, {8.4, -6}};

ou plus simplement :

double[,] réels={ {0.5, 1.7}, {8.4, -6}};

Les tableaux ont une propriété Length qui est le nombre

d'éléments du tableau.

Un tableau à deux dimensions pourra être déclaré comme suit :

Type[,] tableau=new Type[n,m];

où n est le nombre de lignes, m le nombre de colonnes.

La syntaxe Tableau[i,j] désigne l'élément j de la ligne i de tableau. Le

tableau à deux dimensions peut lui aussi être initialisé en même
temps qu'il est déclaré :

double[,] réels=new double[,] { {0.5, 1.7}, {8.4, -6}};

ou plus simplement :

double[,] réels={ {0.5, 1.7}, {8.4, -6}};

Les instructions d’entrée sortie

1. Instruction de lecture
a) Sur la même ligne : Console.In.Read() ;
b) Sur la ligne suivante : Console.In.RealLine() ;
 2. Instruction d’Ecriture :
a) Sur la même ligne : Console.Write() ; ou
Console.Out.Write() ;
b) Sur la ligne Suivante ; Console.WriteLine() ; ou
Console.Out.WriteLine() ;

Les instructions conditionnelles

Dans nos programmes C#, nous allons régulièrement avoir besoin
de faire des opérations en fonction d'un résultat précédent. Par
exemple, lors d'un processus de connexion à une application, si le
login et le mot de passe sont bons, alors nous pouvons nous
connecter, sinon nous afficherons une erreur.

Il s'agit de ce que l'on appelle une condition. Elle est évaluée lors de
l'exécution et en fonction de son résultat (vrai ou faux) nous ferons
telle ou telle chose.

Bien que relativement court, ce chapitre est très important.

N'hésitez pas à le relire et à vous entraîner.

Nous allons voir comment les utiliser en combinaison avec les

instructions conditionnelles.
L'instruction "if"
L’instruction if permet d’exécuter du code si
une condition est vraie (if = si en anglais).
Par exemple :

Code : C#

decimal compteEnBanque = 300 ;

if (compteEnBanque >= 0)
Console .WriteLine ("Votre compte est créditeur" );

Ici, nous avons une variable contenant le solde de notre compte en

banque. Si notre solde est supérieur ou égal à 0 alors nous affichons
que le compte est créditeur.

Pour afficher que le compte est débiteur, on pourrait tester si la

valeur de la variable est inférieure à 0 et afficher que le compte est
débiteur :

Code : C#
 decimal compteEnBanque = 300 ;
if (compteEnBanque >= 0)
Console .WriteLine ("Votre compte est créditeur" );
if (compteEnBanque < 0)
Console .WriteLine ("Votre compte est débiteur" );

Une autre solution est d’utiliser le mot clé else, qui veut dire « sinon
» en anglais.

« Si la valeur est vraie, alors on fait quelque chose, sinon, on fait

autre chose », ce qui se traduit en C# par :

Code : C#

decimal compteEnBanque = 300 ;

if (compteEnBanque >= 0)
Console .WriteLine ("Votre compte est créditeur" );
else
Console .WriteLine ("Votre compte est débiteur" );

Il faut bien se rendre compte que l’instruction if teste si une valeur

est vraie (dans l’exemple précédent la comparaison
compteEnBanque >= 0).

On a vu rapidement dans les chapitres précédents qu’il existait un

type de variable qui permettait de stocker une valeur vraie ou
fausse : le type bool, autrement appelé booléen (boolean en
anglais).
Ainsi, il sera également possible de tester la valeur d’un booléen.
L’exemple précédent peut aussi s’écrire :

Code : C#

decimal compteEnBanque = 300 ;

bool estCrediteur = (compteEnBanque >= 0);
if (estCrediteur )
Console .WriteLine ("Votre compte est créditeur" );
else
Console .WriteLine ("Votre compte est débiteur" );

À noter que les parenthèses autour de l’instruction de comparaison

sont facultatives, je les ai écrites ici pour clairement identifier que la
variable « estCrediteur » va contenir une valeur qui est le résultat de
l’opération de comparaison « compte en banque est supérieur ou
égal à 0 », en l’occurrence vrai.

Voici d’autres exemples pour vous permettre d’appréhender plus

précisément le fonctionnement du type bool :

Code : C#

int age = 30 ;
bool estAgeDe30Ans = age == 30 ;
Console .WriteLine (estAgeDe30Ans ); // affiche True
bool estSuperieurA10 = age > 10 ;
Console .WriteLine (estSuperieurA10 ); // affiche True
bool estDifferentDe30 = age != 30;
Console .WriteLine (estDifferentDe30 ); // affiche False

Un type bool peut prendre deux valeurs, vrai ou faux,

qui s’écrivent avec les mots clés true et false.

Code : C#

bool estVrai = true ;

if (estVrai )
Console .WriteLine ("C'est vrai !" );
else
Console .WriteLine ("C'est faux !" );

Il est également possible de combiner les tests grâce aux opérateurs

de logique conditionnelle, par exemple && qui correspond à
l’opérateur ET.

Dans l’exemple qui suit, nous affichons le message de bienvenue

uniquement si le login est « Nicolas » ET que le mot de passe est «
test ». Si l’un des deux ne correspond pas, nous irons dans
l’instruction else.

Code : C#
 stringlogin= "Nicolas";
stringmotDePasse= "test";
if (login== "Nicolas"&& motDePasse
== "test"
)
Console
.WriteLine
("Bienvenue Nicolas"
);
else
Console
.WriteLine
("Login incorrect"
);

Remarquons ici que nous avons utilisé le test d’égalité « == », à ne pas confondre avec l’opérateur d’affection « = ».
C’est une erreur classique de débutant.

D’autres opérateurs de logiques existent, nous avons notamment

l’opérateur || qui correspond au OU logique :

Code : C#

if (civilite == "Mme" || civilite == "Mlle" )

Console .WriteLine ("Vous êtes une femme" );
else
Console .WriteLine ("Vous êtes un homme" );

L’exemple parle de lui-même ; si la civilité de la personne est Mme

ou Mlle, alors nous avons à faire avec une femme.

A noter ici que si la première condition du if est vraie alors la

deuxième ne sera pas évaluée. C’est un détail ici, mais cela peut
s’avérer important dans certaines situations dont une que nous
verrons un peu plus loin.

Un autre opérateur très courant est la négation que l’on utilise avec
l’opérateur « ! ». Par exemple :

Code : C#

bool estVrai = true ;

if (! estVrai )
Console .WriteLine ("C'est faux !" );
else
Console .WriteLine ("C'est vrai !" );

Ce test pourrait se lire ainsi : « Si la négation de la variable estVrai

est vraie, alors on écrira c’est faux ».
La variable « estVrai » étant égale à true, sa négation vaut false.
Dans cet exemple, le programme nous affichera donc l’instruction
correspondant au else, à savoir « C’est vrai ! ».

Rappelez-vous, nous avons dit qu’une instruction se finissait en

général par un point-virgule. Comment cela se fait-il alors qu’il n’y
ait pas de point-virgule à la fin du if ou du else ?
Et si nous écrivions l’exemple précédent de cette façon ?

Code : C#

bool estVrai = true;

if (!estVrai) Console.WriteLine("C'est faux !");
else Console.WriteLine("C'est vrai !");

Ceci est tout à fait valable et permet de voir où s’arrête vraiment

l’instruction grâce au point-virgule. Cependant, nous écrivons en
général ces instructions de la première façon afin que celles-ci
soient plus lisibles.
Vous aurez l’occasion de rencontrer dans les chapitres suivants
d’autres instructions qui ne se terminent pas obligatoirement par un
point-virgule.

Nous verrons dans le chapitre suivant comment exécuter

plusieurs instructions après une instruction conditionnelle en
les groupant dans des blocs de code, délimités par des accolades « {
» et « } ».

Remarquons enfin qu'il est possible d’enchaîner les tests de manière

à traiter plusieurs conditions en utilisant la combinaison else-if. Cela
donne :

Code : C#

if (civilite == "Mme" )
Console .WriteLine ("Vous êtes une femme" );
else if (civilite == "Mlle" )
Console .WriteLine ("Vous êtes une femme non mariée" );
else if (civilite == "M." )
Console .WriteLine ("Vous êtes un homme" );
else
Console .WriteLine ("Je n'ai pas pu déterminer votre civilité" );
Structure de cas
L’instruction switch effectue un aiguillage vers une ou plusieurs
instructions en fonction du contenu d’une variable de contrôle :

switch (val)
{
case valeur : une ou plusieurs instructions;
break;
case valeur : une ou plusieurs instructions;
break;
default : une ou plusieurs instructions;
}

Le passage d’un case à l’autre n’est pas autorisé sauf dans le cas où
la clause case ne comporte aucune instruction. Si une clause case
comporte au moins une instruction, le passage au case suivant n’est
possible qu’en exécutant goto case (voir les exemples ci-après).

Dans l’exemple suivant (val étant de type entier) :

• Les valeurs 1 et 2 du sélecteur provoquent le même traitement.
• La valeur 3 doit provoquer l’exécution d’une instruction et puis les
instructions du cas 4.

Le case doit dès lors s’écrire comme suit :

switch (val)
{
case 0 : une ou plusieurs instructions;
break;
case 1 :
case 2 : une ou plusieurs instructions;
break;
case 3 : une ou plusieurs instructions;
goto case 4;
case 4 : une ou plusieurs instructions;
break;
default : une ou plusieurs instructions;
}
goto case 2 n’était pas nécessaire au case 1 car il n’y avait là
aucune instruction.

Les Boucles
Quelle que soit la forme de la boucle, les accolades peuvent être
omises si le corps de la boucle se résume à une seule instruction. Un
if, même compliqué, ainsi qu’un do, un while, ou encore un for sont
assimilés à une seule instruction.

Formes while et do while

La forme while consiste à écrire (évaluation de la

condition avant d’exécuter les instructions de la boucle) :

while (condition)
{
une ou plusieurs instructions (formant le corps de la boucle) qui sont
exécutées tant que
la condition est vraie ;
}

La forme do while consiste à écrire (évaluation de la condition après

avoir exécuté les instructions de la boucle) :

do
{
une ou plusieurs instructions ;
} while (condition);

Avec cette seconde forme, la ou les instructions formant le corps de

la boucle sont toujours exécutées au moins une fois.

Forme for

for (instructions d’initialisation; condition; instructions de fin de

boucle)
{
une ou plusieurs instructions qui seront exécutées tant que la
condition est vraie;
}

Dans les parenthèses du for, on trouve trois expressions séparées

par un point-virgule :

1. D’abord la ou les instructions d’initialisation de la boucle

(avec virgule comme séparateur d’instructions) et,
éventuellement, une ou plusieurs déclarations de variable.
2. Ensuite une condition.
 3. Enfin, une ou plusieurs instructions, séparées dans ce cas
par virgule, qui sont exécutées après chaque passage dans
la boucle.

Les instructions break et continue

Les instructions break et continue peuvent être exécutées dans une

boucle :

1. L’instruction continue fait passer directement à l’itération

suivante ;
2. L’instruction break fait quitter la boucle.

Ainsi, la boucle :

for (int i=0; i<5; i++)

{
// Afficher(i);
if (i == 2) continue;
Console.Write("A");
if (i == 3) break;
// Afficher ("B");
}

affiche 0AB1AB23A.

1. La gestion des exceptions

De nombreuses fonctions C# sont susceptibles de
générer des exceptions, c'est à dire des erreurs. Lorsqu'une
fonction est susceptible de générer une exception, le programmeur
devrait la gérer dans le but d'obtenir des programmes plus résistants
aux erreurs : il faut toujours éviter le "plantage" sauvage d'une
application.

La gestion d'une exception se fait selon le schéma suivant :

try{
code susceptible de générer une exception
} catch (Exception e){
traiter l'exception e
}
instruction suivante
Si la fonction ne génère pas d'exception, on passe alors à
instruction suivante, sinon on passe dans le corps de la clause catch
puis à instruction suivante.

N.B : e est un objet de type Exception ou dérivé.

On peut ajouter aux clauses try/catch, une clause finally :

try{
code susceptible de générer une exception
} catch (Exception e){
traiter l'exception e
}
finally{
code exécuté après try ou catch
}
instruction suivante
Qu'il y ait exception ou pas, le code de la clause finally sera toujours
exécuté.
La classe Exception a une propriété Message qui est un message
détaillant l'erreur qui s'est produite. Ainsi si on veut afficher celui-ci,
on écrira :

catch (Exception ex){

MessageBox.Show("L'erreur suivante s'est produite :
{0}",ex.Message);
...
}//catch
La classe Exception a une méthode ToString qui rend une chaîne
de caractères indiquant le type de l'exception ainsi que la valeur de
la propriété Message. On pourra ainsi écrire :

catch (Exception ex){

MessageBox.Show ("L'erreur suivante s'est produite : {0}",
ex.ToString());
...
}//catch
On peut écrire aussi :
catch (Exception ex){
MessageBox.Show ("L'erreur suivante s'est produite : {0}",ex);
...
}//catch
Le compilateur va attribuer au paramètre {0}, la valeur
ex.ToString().

Chap. 2 : Créer un projet avec Visual Studio 2012

Dans ce chapitre nous allons faire nos premiers pas avec le C#.
Nous allons dans un premier temps installer et découvrir les outils
qui nous seront nécessaires pour réaliser des applications
informatiques avec le C#. Nous verrons comment démarrer avec ces
outils et à la fin de ce chapitre, nous serons capables de créer un
petit programme qui affiche du texte simple et nous aurons
commencé à nous familiariser avec l’environnement de
développement.

Bien sûr, vous allez avoir besoin d’un ordinateur, mais a priori, vous
l’avez déjà … S’il n’est pas sous Windows, mais sous linux, vous
pouvez utiliser Mono qui va permettre d’utiliser le C# sous linux.
Cependant, Mono n’est pas aussi complet que le C# et le
framework .NET sous Windows, en l’utilisant vous risquez de passer
à côté de certaines parties du tutoriel.

Pour reprendre la métaphore du chantier, on peut dire qu’il va

également nous manquer un chef de chantier. Il n’est pas forcément
nécessaire en théorie, mais dans la pratique il se révèle
indispensable pour mener à bien son chantier.

Ce chef de chantier c’est en fait l’outil de développement. Il va

nous fournir les outils pour orchestrer nos développements.
C’est entre autres :

Un puissant éditeur
Un compilateur
Un environnement d’exécution

L’éditeur de texte va nous servir à créer des fichiers contenant

des instructions en langage C#.
Le compilateur va servir à transformer ces fichiers en une suite
d'instructions compréhensibles par l'ordinateur, comme nous l'avons
déjà vu.
Le moteur d’exécution va permettre de faire les actions
informatiques correspondantes (afficher une phrase, réagir au clic de
la souris, etc.), c'est le CLR dont on a déjà parlé.

Enfin, nous aurons besoin d’une base de données. Nous y

reviendrons plus en détail ultérieurement, mais la base de données
est un endroit où seront stockées les données de notre application.
C’est un élément indispensable à mesure que l’application grandit.
Installer Visual studio 2012
Nous avons donc besoin de notre chef de chantier, l’outil de
développement. C’est un logiciel qui va nous permettre de créer des
applications et qui va nous fournir les outils pour orchestrer nos
développements. La gamme de Microsoft est riche en outils
professionnels de qualité pour le développement, notamment grâce
à Visual Studio.

Notez que cet outil de développement se nomme également un IDE

pour « Integrated Development Environment » ce qui signifie «
Environnement de développement intégré ».

Une fois l’exécutable téléchargé, il ne reste plus qu’à le lancer et

l’installation démarre :
Acceptez les conditions d’utilisation de la licence et lliquez sur
Suivant pour démarrer l’installation :

Vous devez à présent lire la licence d'utilisation du logiciel et

l'accepter pour pouvoir continuer l'installation :

Cochez toutes les fonctionnalités et Cliquez sur Installer

L'installation démarre (vous devez être patient) :

Une fois l'installation terminée cliquez sur Lancer

Vous voilà avec votre copie de Visual Studio 2012 qui va vous
permettre de créer des programmes en C# gratuitement et
facilement. L'installation de l'outil de développement est terminée.

En résumé, nous avons installé un outil de développement, Visual

Studio 2012. Nous avons tous les outils nécessaires et nous allons
pouvoir démarrer (enfin !) l'apprentissage et la pratique du C#.
Démarrer Visual Studio 2012
Visual Studio 2012 se démarre comme tout autre programme sur
Windows, il suffit de double-cliquer sur on icone se trouvant sur le
bureau de Windows ou sur aller dans le menu démarrer, tout
programme et cliquer sur Visual Studio 2012.

Le logiciel s’ouvre sur la page de paramètre de Visual Studio 2012 :

Sélectionnez les Paramètre de développement Visual C# et cliquer

sur démarrer Visual Studio
Les deux zones entourées de rouge permettent respectivement de
créer un nouveau projet et d’accéder aux anciens projets déjà créés.
Dans ce deuxième cas, comme je viens d’installer le logiciel, la liste
est vide.
Créer un projet
Commençons par créer un nouveau projet en cliquant dans la zone
droite. Cette commande est également accessible via le menu
Fichier > Nouveau > Projet
Un projet va contenir les éléments de ce que l’on souhaite réaliser.
Cela peut être par exemple une application web, une application
Windows, Etc …

Le projet est aussi un container de fichiers et notamment dans notre

cas de fichiers en langage C# qui vont permettre de construire ce
que l’on souhaite réaliser. Le projet est en fait représenté par un
fichier dont l’extension est .csproj. Son contenu décrit les
paramètres de configuration correspondant à ce que l’on souhaite
réaliser et les fichiers qui composent le projet.

Créons donc un nouveau projet. La fenêtre de création de nouveau

projet s’ouvre et nous avons plusieurs possibilités de choix. Nous
allons dans un premier temps aller dans Visual C# pour choisir de
créer une Application console.
Si vous naviguez à l’intérieur des différents modèles, vous pourrez
constater que Visual C# nous propose des modèles de projets plus
ou moins compliqués. Ces modèles sont très utiles pour démarrer un
projet car toute la configuration du projet est déjà faite. Le nombre
de modèles peut être différent en fonction de votre version de Visual
Studio ou du nombre de versions express installées.

L’application Console est la forme de projet pouvant produire une

application exécutable la plus simple. Elle permet de réaliser un
programme qui va s’exécuter dans la console noire qui ressemble à
une fenêtre ms-dos, pour les dinosaures comme moi qui ont connu
cette époque … A noter que les projets de type « Bibliothèque de
classes » permettent de générer des assemblys de bibliothèques
(.dll).

Dans cette console, nous allons pouvoir notamment afficher du texte

simple.
Ce type de projet est parfait pour démarrer l’apprentissage du C#
car il n’y a besoin que de savoir comment afficher du texte pour
commencer alors que pour réaliser une application graphique par
exemple, il y a beaucoup d’autres choses à savoir.

En bas de la fenêtre de création de projet, nous avons la possibilité

de choisir un nom pour le projet, ici
ConsoleApplication1. Changeons le nom de notre application, par
exemple "Ma_Premiere_Application", dans la zone correspondante.
Cliquons sur OK pour valider la création de notre projet.

Visual studio crée alors pour nous les fichiers composant une
application console vide, qui utilise le C# comme langage et que
nous avons nommé Ma_Premiere_Application.

Analyse rapide de l’environnement de développement et

du code généré

Dans l’emplacement renseigné (ici c:\users\joseph\documents\

visual studio 2012\Projects), nous pouvons constater que Visual
Studio a créé un répertoire Ma_Premiere_Application, c’est le
fameux répertoire pour la solution qu’il nous a proposé de créer.

Dans ce répertoire, nous remarquons notamment un fichier

Ma_Premiere_Application.sln.

C’est ce qu'on appelle le fichier de solution ; il s’agit juste d’un

container de projets qui va nous permettre de visualiser nos projets
dans visual C# express.

En l’occurrence, pour l’instant, nous avons un seul projet dans la

solution : l’application Ma_Premiere_Application, que nous
retrouvons dans le sous répertoire Ma_Premiere_Application et qui
contient notamment le fichier de projet :
Ma_Premiere_Application .csproj.
Il y a encore un fichier digne d’intérêt (pour l’instant) dans ce
répertoire, il s’agit du fichier Program.cs. Les fichiers dont
l’extension est .cs contiennent du code C#, c’est dans ce fichier que
nous allons commencer à taper nos premières lignes de code …

Si nous retournons dans l’interface de Visual Studio, nous pouvons

retrouver quelque chose comme ça :

La zone verte numéro 1 contient les différents fichiers ouverts sous

la forme d’un onglet. On voit que par défaut, Visual C# nous a créé
et ouvert le fichier Program.cs.

Dans la zone rouge numéro 2, c’est l’éditeur de code. Il affiche le

contenu du fichier ouvert. Nous voyons des mots que nous ne
comprenons pas encore. C’est du code qui a été automatiquement
généré par Visual Studio, Nous pouvons observer que les mots sont
de différentes couleurs. En effet, l’éditeur Visual Studio possède ce
qu’on appelle une coloration syntaxique, c'est-à-dire que certains
mots clés sont colorés d’une couleur différente en fonction de leur
signification ou de leur contexte afin de nous permettre de nous y
retrouver plus facilement.

La zone numéro 3 est l’explorateur de solutions, c’est ici que l’on

voit le contenu de la solution sur laquelle nous travaillons en ce
moment. En l’occurrence, il s’agit de la solution «
Ma_Premiere_Application » qui contient un unique projet «
Ma_Premiere_Application ». Ce projet contient plusieurs sous
éléments :

 Properties : contient des propriétés de l’application ;

 Références : contient les références de l’application ;
 Program.cs : est le fichier qui a été généré par Visual studio
et qui contient le code C# ;
 App.confing : Permet de personnaliser la façon dont le CLR
(Common Language Runtime), il localise et charge les
fichiers d’assembly.

La zone 4 est la zone contenant les propriétés de ce sur quoi nous

travaillons en ce moment. Ici, nous avons le curseur positionné sur le
projet, il n’y a pas beaucoup d’informations excepté le nom du
fichier de projet. Nous aurons l’occasion de revenir sur cette fenêtre
plus tard.

La zone 5 n’est pas affichée au premier lancement, elle contient la

liste des erreurs, des avertissements et des messages de notre
application.

La zone 6 est la barre d'outils, elle possède plusieurs boutons que

nous pourrons utiliser, notamment pour exécuter notre application.
Ecrire du texte dans notre application
Allons donc dans la zone 2 réservée à l’édition de notre fichier
Program.cs qui est le fichier contenant le code C# de notre
application.

Les mots présents dans cette zone sont ce qu’on appelle des
instructions de langage. Elles vont nous permettre d’écrire notre
programme.

Exemple d’une instruction :

Console.WriteLine ("Bonjour") ;

de manière à avoir :

static void Main(string [] args)

{
Console.WriteLine ("Bonjour") ;
}
Nous venons d’écrire une instruction qui va afficher la phrase
“Bonjour”.
L'exécution du projet
La première chose à faire est de transformer le langage C# que nous
venons d’écrire en programme exécutable. Cette phase s’appelle la
« génération de la solution » sous Visual Studio. On l’appelle souvent
la « compilation » ou en anglais le « build ».

Allez dans le menu Déboguer et cliquez sur « Démarrer le débogage

» soit cliquer sur le bouton demarrer dans la barre d’outil ou encore
faire la combinaison des touches CTRL+F5 :

La console s’ouvre nous délivrant le message tant attendu :

Nous sommes désormais fin parés pour apprendre le C#.

En résumé

Visual Studio est l’outil de développement payant de Microsoft

permettant d’être efficace dans le développement
d’applications .NET.