BTS SIO SI4

Démarrage en C#

COURS C#

Date Révision
Août 2018 Création (v95)
Décembre 2020 Modification pour adaptation SLAM2 (v.102)

David ROUMANET 01/02/2020 (v.101) 1

 BTS SIO SI4
Démarrage en C#

TABLE DES MATIÈRES

1 Généralités.............................................................................................................................5
1.1 Introduction.....................................................................................................................5
1.2 Prérequis.........................................................................................................................5
1.3 Objectifs..........................................................................................................................5

2 Programmation C#.................................................................................................................6
2.1 Environnement de développement.................................................................................6
2.2 Structure d'un programme C#........................................................................................6
2.2.1 Commentaires /* et */..............................................................................................7
2.2.2 Blocs { et }................................................................................................................7
2.2.3 Bibliothèques (using)...............................................................................................7
2.3 En résumé.......................................................................................................................8
2.4 Syntaxe d’écriture...........................................................................................................8
2.5 Les instructions...............................................................................................................9
2.6 Auto-évaluation chapitre 1............................................................................................10

3 Types de données................................................................................................................11
3.1 Les types primitifs.........................................................................................................11
3.1.1 Déclaration d'une variable primitive......................................................................12
3.1.2 affectation d'une variable primitive........................................................................12
3.2 Les constantes..............................................................................................................12
3.3 Déclaration d’une variable sans type : var....................................................................12
3.4 Les classes conteneurs................................................................................................13
3.4.1 Déclaration.............................................................................................................13
3.4.2 affectation..............................................................................................................13
3.4.3 Utilisation des classes conteneurs........................................................................13
3.5 Les conversions............................................................................................................14
3.5.1 Conversions implicites...........................................................................................14
3.5.2 Conversions explicites...........................................................................................14
3.5.3 Conversions de chaîne vers nombre.....................................................................14
3.5.3.1 La méthode ‘Convert.’.......................................................................................................14
3.5.4 Conversions de nombre vers chaîne.....................................................................15
3.5.4.1 La méthode ‘toString’.........................................................................................................15

4 Les opérations......................................................................................................................16
4.1 Les opérations arithmétiques........................................................................................16
4.1.1 Opérations simples................................................................................................16
4.1.2 Opérations complexes...........................................................................................16
4.1.3 Opérations particulières.........................................................................................16
4.2 Les opérations binaires.................................................................................................16
4.3 Les opérations de chaînes............................................................................................17
4.3.1 Formatage des affichages.....................................................................................17

David ROUMANET 01/02/2020 (v.101) 2

 BTS SIO SI4
Démarrage en C#

5 Les tableaux.........................................................................................................................19
5.1.1 déclaration.............................................................................................................19
5.1.2 affectation..............................................................................................................19

6 Les entrées-sorties standards..............................................................................................21

6.1 Mode console................................................................................................................21
6.1.1 Affichage................................................................................................................21
6.1.2 Saisie.....................................................................................................................21
6.1.3 Debug....................................................................................................................22
6.2 Fichiers..........................................................................................................................23

7 Exercice................................................................................................................................26
7.1 Enregistrer un fichier contenant une fiche contact.......................................................26
7.2 Source fichier................................................................................................................26

8 Boucles et conditions...........................................................................................................27
8.1 Boucles.........................................................................................................................27
8.1.1 Boucle for ou Foreach...........................................................................................27
8.1.2 Boucle while...........................................................................................................27
8.1.3 Boucle Do… while.................................................................................................28
8.2 Conditions.....................................................................................................................28
8.2.1 Conditions IF - ELSE.............................................................................................28
8.2.2 Conditions SWITCH - CASE.................................................................................29
8.2.3 Portée de variables................................................................................................29

9 Les fonctions........................................................................................................................31
9.1 Création d’une fonction.................................................................................................32
9.2 Appel d’une fonction......................................................................................................32
9.3 Entraînez-vous : fonction SaisirNombre(int min, int max)............................................33

10 Les exceptions...................................................................................................................34
10.1 Arborescence des exceptions.....................................................................................34
10.1.1 Exemple de code avec erreur.............................................................................34
10.2 Gestion des exceptions rencontrées..........................................................................35
10.2.1 Exemple de code avec gestion d’erreur..............................................................35

11 Les interfaces graphiques..................................................................................................37

11.1 Fonctionnement..........................................................................................................37
11.2 Visual Studio et projet Windows Forms......................................................................38
11.2.1 Les fichiers...........................................................................................................39
11.2.2 Les morceaux de code........................................................................................39
11.2.2.1 Program.cs.......................................................................................................................39
11.2.2.2 Form.Designer.cs.............................................................................................................40
11.2.2.3 Form1.cs..........................................................................................................................41
11.3 Ce qui faut retenir en programmation événementielle................................................41

David ROUMANET 01/02/2020 (v.101) 3

 BTS SIO SI4
Démarrage en C#

12 Les objets...........................................................................................................................42
12.1 Vocabulaire.................................................................................................................42
12.2 Représentation............................................................................................................42
12.2.1 instanciation.........................................................................................................43
12.2.2 Accesseurs et mutateurs.....................................................................................44
12.2.3 Portées et modificateurs......................................................................................44
12.2.3.1 pour les classes...............................................................................................................44
12.2.3.2 Pour les méthodes...........................................................................................................44
12.2.3.3 Pour les attributs..............................................................................................................45
12.2.4 Analyse d’un programme.....................................................................................45
12.3 Résumé.......................................................................................................................46
12.4 Héritage......................................................................................................................47
12.4.1 Exemple...............................................................................................................47
12.4.2 Déclaration...........................................................................................................47
12.4.3 Utilisation.............................................................................................................48
12.4.4 Exemple de codage (TD à reproduire)................................................................48
12.4.5 Exercice...............................................................................................................50

13 Les classes abstraites et interfaces...................................................................................51

13.1 Classe abstraite..........................................................................................................51
13.1.1 Exercice...............................................................................................................52
13.1.2 Exercice...............................................................................................................52
13.2 Les interfaces..............................................................................................................52

14 Annexes..............................................................................................................................54

David ROUMANET 01/02/2020 (v.101) 4

 BTS SIO SI4
Démarrage en C#

1 GÉNÉRALITÉS

1.1 INTRODUCTION
Vous avez déjà des notions de programmation, dans un autre langage. Ce support s'appuie sur
votre compréhension des boucles, des conditions et des fonctions.
Chaque langage utilise sa propre syntaxe et ses propres mots clés, mais les principes fondamentaux
restent les mêmes : C# est un langage créé par Microsoft, pour séduire les programmateurs C tout
en apportant la rigueur de gestion et la virtualisation de Java.
Ainsi, on retrouve ces deux langages dans le fonctionnement de C#.

1.2 PRÉREQUIS
Ce support de cours s'adresse aux étudiants ayant déjà suivi le cours SI4 et ayant acquis les notions
suivantes :
• Les variables et les constantes
• Les tableaux (à une ou plusieurs dimensions)
• Les boucles (répétitions de type 'for', 'do while' et 'while')
• Les conditions (tests utilisant 'if … elseif… else')
• les fonctions (déclarations, passage de paramètres, valeurs de retour, appels)

1.3 OBJECTIFS
C# est un langage qui entre dans la famille des machines virtuelles. À ce titre, il n'est n'y vraiment
compilé (le compilateur ne renvoie pas un exécutable binaire), ni interprété… cependant, son
fonctionnement le rapproche des langages compilés et son environnement de travail aussi.
Vous saurez donc :
• rédiger un programme
• appeler des bibliothèques
• compiler un programme
• utiliser l'environnement de travail pour déboguer

David ROUMANET 01/02/2020 (v.101) 5

 BTS SIO SI4
Démarrage en C#

2 PROGRAMMATION C#

2.1 ENVIRONNEMENT DE DÉVELOPPEMENT

Un environnement spécifique est utilisé pour C# : Visual Studio XXXX (qu'il ne faut pas confondre
avec Visual Studio Code).

La première chose à faire est d'installer un environnement de développement (aussi appelé IDE
pour integrated development environment).

2.2 STRUCTURE D'UN PROGRAMME C#

Le premier code de base (mode console) en C# se présente comme suit :
/* Voici le code d'exemple de base : Hello World */
using System;
using System.Text; // le double slash permet d'écrire un commentaire sur une ligne

namespace HelloWorld
{
class Program
{
static void Main(string[] args) {
Console.WriteLine("Hello World");
Console.ReadKey();
}
}
}

David ROUMANET 01/02/2020 (v.101) 6

 BTS SIO SI4
Démarrage en C#

2.2.1 COMMENTAIRES /* ET */
Pour C#, les lignes comprises entre /* et */ ne sont pas lues : cela permet au programmeur de
placer des commentaires avant un code complexe, ou bien décrire rapidement ce que fait
l’application.
Il est important de comprendre qu’il faut une convention d’écriture commune à tous les
programmeurs. On utilise donc des balises ouvrantes et fermantes, un peu comme en français, les
symboles ‟ et ” indique que le texte contenu entre les deux symboles et dit à haute voix par
exemple.
Sur une ligne seulement (ou bien après une instruction) C# accepte le double symbole //.

2.2.2 BLOCS { ET }
L’utilisation de blocs, permet à l’interpréteur C# de comprendre que l’ensemble des instructions
comprises entre { et } vont ensemble et constituent un bloc non-sécable.
Ici, namespace est une sorte de classeur qui contient tout le programme. Si le programme est
constitué de plusieurs fichiers, ils doivent avoir le même namespace. Ici, le programme n’est
constitué que d’une seule classe ‘Program’ qui elle-même ne contient qu’une méthode ‘Main’.
Cette structure permet de découper un programme en section logique (on regroupe ensemble, les classes et fonctions
qui agissent de manière similaire ou qui ont un lien commun sur les données ou les interfaces). Si vous ne comprenez
pas cette phrase, c’est tout à fait normal lorsque l’on commence à programmer avec un langage comme celui-ci…

2.2.3 BIBLIOTHÈQUES (USING)

En programmation, il existe de nombreuses instructions et fonctions qui ne nécessitent pas d’être
écrites, car les programmeurs ont déjà fait ce travail. En bricolage, on utilise des outils existants et
un bricoleur n’a pas à ré-inventer le tournevis ou la pince.
En programmation, ces outils sont des bibliothèques de fonctions (ou méthodes). Pour éviter
d’avoir une boite à outils trop lourde, C# demande de préciser en début de programme les
bibliothèques qui seront utilisées.
Par défaut Visual Studio propose d’utiliser 5 bibliothèques, mais ce n’est pas nécessaire pour un
programme aussi simple.

David ROUMANET 01/02/2020 (v.101) 7

 BTS SIO SI4
Démarrage en C#

2.3 EN RÉSUMÉ
Le schéma ci-après donne un exemple d’analogie possibles

2.4 SYNTAXE D’ÉCRITURE

C# utilise une syntaxe simple mais très codifié :
• Les instructions se terminent par un point-virgule ( ; ) comme une phrase en français se
termine par un point.
• Les noms de classes commencent par une majuscule. Pour le moment, une classe est un
regroupement de commandes, un peu comme une pochette transparente dans un classeur, qui
contient plusieurs feuilles

David ROUMANET 01/02/2020 (v.101) 8

 BTS SIO SI4
Démarrage en C#

• Les fonctions (appelées aussi méthodes) et variables ne commencent pas par une majuscule.
Considérez qu’une fonction est un regroupement d’instructions qui seront exécutées lignes
après lignes, jusqu’à la fin du bloc fonction.
• C# utilise la notation "camel" à l’exception des règles sur la première lettre. Ainsi, une méthode
(fonction) pour colorier un rectangle s’écrira "colorierRectangle". Seules les classes s’écrivent
avec la première lettre en majuscule
• Les variables peuvent utiliser tous les caractères alphabétiques (accentués compris) mais ne
peuvent commencer par un chiffre, ou porter le nom d’un mot-clé de C#
• Les conditions seront encadrées par des parenthèses ().
• Les blocs d’instructions seront encadrés par des crochets {}
• Un commentaire d’une ligne commencera par deux ‘slash’ //
• Un bloc de commentaires (plusieurs lignes) s’écrit entre /* et */
• Un bloc de commentaires pour C#doc s’écrit entre /** et */
• Les crochets carrés sont utilisés pour les tableaux [ ]
• Le point ( . ) est généralement utilisé pour lier les méthodes (fonctions) aux variables (objets),
c’est le lien entre le sujet et le verbe (moi.Écrire(quelquechose) ou document.Imprimer(), etc.)

2.5 LES INSTRUCTIONS

Voici enfin les instructions :
Console.WriteLine("Hello World");
Console.ReadKey();
En français, nous pourrions dire "sur l'objet console, écrire ‘Hello Word’ puis sur l'objet console, lire
une touche du clavier". C'est une écriture des langages orientés objet (POO).

En cliquant sur ► Démarrer, une console doit s’ouvrir et afficher notre message.

David ROUMANET 01/02/2020 (v.101) 9

 BTS SIO SI4
Démarrage en C#

2.6 AUTO-ÉVALUATION CHAPITRE 1

Voici quelques questions pour valider votre compréhension et approfondir vos connaissances…

Question ou affirmation Vrai ou Faux

À la fin de chaque ligne, on ajoute un point
Les instructions sont regroupées dans un paquet
L’espace de nom contient les classes qui contiennent les méthodes (fonctions)
La variable RdV_de_l’Heure est possible en C#
Le mot-clé "using" est une instruction d’affichage
Console.ReadKey() applique la fonction ReadKey() sur la console ouverte

Réponses :
Faux c’est point-virgule ; Faux c’est regroupé dans un bloc ; Vrai ; Faux car contient un symbole (‘) ; Faux using
intègre les bibliothèques ; Vrai.

David ROUMANET 01/02/2020 (v.101) 10

 BTS SIO SI4
Démarrage en C#

3 TYPES DE DONNÉES

Dans les langages de programmation typés, c’est le programmeur qui choisit l’espace de valeurs
pour les variables. En Python ou PHP (qui ne sont pas typés), l’interpréteur suppose le type
automatiquement. En C#, C++, Java et de nombreux autres langages, le programmeur peut
optimiser son code (pour le rendre plus performant en vitesse et occupation mémoire) en
choisissant lui-même le type de ses variables.

3.1 LES TYPES PRIMITIFS

Seules les données numériques sont des types primitifs, avec deux exceptions : le caractère et le
booléen.
Les types primitifs sont déclarés avec un mot-clé en minuscule devant le nom de la variable.
Type Représente Plage Valeur par défaut
bool bololéen True ou False False
byte 8 bits non signés 0 à 255 0
char 16 bits Unicode U +0000 à U +FFFF '\0'
28 28
decimal 128 bits -7.9x10 à +7.9x10 0.0M
-324 308
double 64 bits +/- 5x10 à +1.7*10 0.0D
38 38
float 32 bits -3.4 x 10 à +3.4 x 10 0.0F
int 32 bits signés -2147483648 à +2147483647 0
long 64 bits signés +/- 9223372036854775808 environ 0L
sbyte 8 bits signés -128 à +127 (0x7F) 0
short 16 bits signés -32768 à +32767 (0x7FFF) 0
uint 32 bits non signés 0 à 4294967295 (0xFFFFFFFF) 0
Différences Java :
ulong 64 bits non signés 0 à 18446744073709551615 0 Les types non-signés
n’existent pas en Java
ushort 16 bits non singés 0 à 65535 0

En Java, le type non-signé n'existent pas. Pour obtenir une valeur de type signé en utilisant un type
non-signé, il suffit d'appliquer un masque booléen de la taille du type de variable.
valeur = valeur & 0xFF…

David ROUMANET 01/02/2020 (v.101) 11

 BTS SIO SI4
Démarrage en C#

3.1.1 DÉCLARATION D'UNE VARIABLE PRIMITIVE

En C#, il faut faire précéder le nom de la variable par son type.
int unEntier;
char uneLettre;

3.1.2 AFFECTATION D'UNE VARIABLE PRIMITIVE

unEntier = 25;
uneLettre = 'c';

Il est possible de faire la déclaration et l’affectation sur la même ligne :

double unDecimal = 2.5;

3.2 LES CONSTANTES

Pour déclarer n’importe quelle variable (on dit aussi attribut), il suffit d’ajouter le mot-clé const
devant la déclaration. Cette variable n’est alors plus modifiable ailleurs.
const double pi = 3.14159;

3.3 DÉCLARATION D’UNE VARIABLE SANS TYPE : VAR

C# permet (avantage sur Java) de déclarer une variable, sans préciser le type. Lors de la première
affectation, le compilateur essayera de deviner son type.
var maVariable = 1.68 ; // variable de type float ou double

David ROUMANET 01/02/2020 (v.101) 12

 BTS SIO SI4
Démarrage en C#

3.4 LES CLASSES CONTENEURS

Pour manipuler plus facilement les types primitifs ou permettre l’utilisation de chaînes de
caractères, C# propose des classes conteneurs (ou classes références, en anglais "wrapper classes").
On les reconnaît par la présence d’une majuscule dans le type : cela indique que le type est un
objet.
Les classes conteneurs usuelles sont :
• Byte, Sbyte, Int16, Int32, Int64
• Double
• Char, Boolean

3.4.1 DÉCLARATION
Int32 unEntier;
String unMot;
Boolean monDrapeau;

3.4.2 AFFECTATION

unEntier = 25;
unMot = "Bonjour le monde";
monDrapeau = true; // ne peut prendre que true ou false

En effet, certaines méthodes ne permettent que l’utilisation d’objet (comme les méthodes de la classe ArrayList). Il était
nécessaire d’encapsuler les types primitifs dans un objet. Par exemple :
int myInt = 5 ;
list.add(new Int32(myInt)) ; // ce mécanisme de boxing est relativement lourd. Les classes conteneurs facilitent tout.

3.4.3 UTILISATION DES CLASSES CONTENEURS

Les classes conteneurs sont intéressantes pour certaines manipulations. Dans la pratique, les
chaînes de caractères sont les plus concernées. Le reste concerne notamment les collections et
listes.

David ROUMANET 01/02/2020 (v.101) 13

 BTS SIO SI4
Démarrage en C#

3.5 LES CONVERSIONS

L’interpréteur C# refuse les conversions qui risquent de faire perdre de l’information.
Contrairement à d'autres langages comme JavaScript, C# ne fera de conversion que sur les nombres
sans risque de pertes de précision.

3.5.1 CONVERSIONS IMPLICITES

Ainsi, l’opération suivante ne pose aucun problème, car un entier est inclus dans les décimaux :
double monDecimal = 0.3;
int monEntier = 5;
monDecimal = monEntier;

3.5.2 CONVERSIONS EXPLICITES

En revanche, l’inverse nécessite que le programmeur ‘confirme’ de manière explicite le risque de
perte d’information, par l’ajout du type souhaité entre parenthèse avant le nom de variable :
double monDecimal = 7.35;
int monEntier = 5;
monEntier = (int)monDecimal; // on appelle cela un cast, on accepte de perdre 0.35

Pour synthétiser, un byte est inclus dans un short qui est inclus dans un int qui est inclus dans un long qui est inclus
dans un float qui est inclus dans un double. Un char sera inclus uniquement à partir d’un int, car il n’a pas de bit de
signe.

3.5.3 CONVERSIONS DE CHAÎNE VERS NOMBRE

Une chaîne peut contenir des caractères numériques, mais cela n'en fait pas un nombre : "3.5"
n'est pas 3.5 (les guillemets permettent de savoir s'il s'agit d'une chaîne). La conversion d’une
chaîne de caractères vers un nombre est possible par l’utilisation de méthodes existantes dans les
classes correspondantes. Il faut donc utiliser les classes conteneurs vues précédemment.

3.5.3.1 LA MÉTHODE ‘CONVERT.’

String maChaine="5.68";
Double d;
d = Convert.ToDouble(maChaine);

On peut convertir
En entier En entier non-signé En décimal Autre
ToInt16 ToUint16 ToDecimal (128 bits) ToBoolean
ToInt32 ToUint32 ToDouble (64 bits) ToDateTime
ToInt64 ToUint64

David ROUMANET 01/02/2020 (v.101) 14

 BTS SIO SI4
Démarrage en C#

3.5.4 CONVERSIONS DE NOMBRE VERS CHAÎNE

L’opération permettant de convertir un nombre dans une chaîne existe aussi, en utilisant là encore
des méthodes dans les classes conteneurs.

3.5.4.1 LA MÉTHODE ‘TOSTRING’

String maChaine = "";
Double d = 5.68;
maChaine = d.toString();

David ROUMANET 01/02/2020 (v.101) 15

 BTS SIO SI4
Démarrage en C#

4 LES OPÉRATIONS

4.1 LES OPÉRATIONS ARITHMÉTIQUES

4.1.1 OPÉRATIONS SIMPLES

Les opérations d’addition, soustraction, multiplication, soustraction et modulo sont supportées :
Double d = 5.68;
Int32 e = 120;
d = d * 1.20 / 5 + 3.14 – 6.222;
e = e % 100; // retourne 20 car 120/100 = 1 et il reste 20

Les priorités sont respectées (multiplication et division passent avant l’addition et la soustraction)

4.1.2 OPÉRATIONS COMPLEXES

Les opérations trigonométriques, la génération de nombres aléatoires, l’utilisation de racines carrés
ou puissances nécessitent les méthodes contenues dans la classe Math.
Double a, b, c, d;
a = Math.Sin(3.14/2);
b = Math.Pow(5,2); // 5² ou 5 à la puissance 2
c = Math.Sqrt(c); // √c (racine, en anglais, square)

Pour les nombres aléatoires, il faut utiliser la classe Random

4.1.3 OPÉRATIONS PARTICULIÈRES

Quelques opérations sont pratiques et doivent êtres connues.
• Incrémentation : d++ (équivalent à d = d + 1)
• Décrémentation : d-- (équivalent à d = d - 1)
• Cumul : total+= d (équivalent à total = total + d)

4.2 LES OPÉRATIONS BINAIRES

Il s’agit d’opérations sur les bits des variables : ET, OU, NON, << et >>, etc.
int a, b, c, d, e, f;
a = 0b1100 & 0b1010; // ET : renvoie 1000 (notez la notation binaire '0b')
b = 0b1100 | 0b1010; // OU : renvoie 1110
c = 0b1100 ^ 0b1010; // OU exclusif : renvoie 0110

David ROUMANET 01/02/2020 (v.101) 16

 BTS SIO SI4
Démarrage en C#

d = !0xF0; // NON : renvoie 0F

e = 0x0F << 8; // Décalage par 8 à gauche : renvoie F0

Attention à ne pas confondre opérations binaires et comparateurs (&&, ||, !=, ==, ≥=, <=... )

4.3 LES OPÉRATIONS DE CHAÎNES

Ce sont les opérations disponibles pour le traitement de chaînes de caractères ou de caractères : il
faut cependant se souvenir que C# travaille en Unicode ! La taille d’un caractère n’est donc pas un
octet comme en ASCII.
Différences Java :
En Java, SubString utilise
• Méthodes toLower() et toUpper() changent la casse de la chaîne PDepart et pFin
On utilise .toLowerCase et
• Méthode length renvoie la taille de la chaîne (en nombre de caractère) .toUpperCase

• Méthodes Substring(pDepart, pLongueur) affiche un ou plusieurs caractères

• Méthode Replace(chOrigine,chFinale) remplace une chaîne par une autre
• Méthode de recherche Contains(strRecherchee) pour trouver une chaîne dans une autre
• Méthode Split(strSepare) pour séparer une chaîne en plusieurs chaînes

Quelques exemples d’utilisations sont données ci-dessous :

String maChaine = "Bonjour";
String monPrenom = "Coco";
char maLettre = ' ';

Console.writeLine(maChaine.toLower()); // affiche 'bonjour'

Console.writeLine(maChaine.toUpper()); // affiche 'BONJOUR'
Console.writeLine(maChaine.length); // affiche 7
Console.writeLine(maChaine.SubString(4,1)); // affiche 'j'
String messageCool = maChaine+maLettre+monPrenom; //contient 'Bonjour Coco'
String message2 = maChaine.concat(monPrenom); // contient BonjourCoco

Voir https://msdn.microsoft.com/en-us/library/system.string(v=vs.110).aspx

4.3.1 FORMATAGE DES AFFICHAGES

L’affichage en C# n’est pas aussi puissant que la méthode printf() de Java.
Il faut donc passer par une conversion en une chaîne avec string.Format
Un exemple (utilisant les arguments {numéro} ) :
double a = 5.6d;
double b = 2d;
double mult = a * b;
string s = string.Format("{0:0.00}", mult);

David ROUMANET 01/02/2020 (v.101) 17

 BTS SIO SI4
Démarrage en C#

Console.WriteLine("{0} fois {1} égal {2}", a, b , mult);

Console.WriteLine(a.toString()+" fois "+b.toString()+" égal "+mult);

affichera : 5,6 fois 2 égal 11,20

5,6 fois 2 égal 11,20

David ROUMANET 01/02/2020 (v.101) 18

 BTS SIO SI4
Démarrage en C#

5 LES TABLEAUX

Un tableau est un ensemble de variables de même type dans une quantité définie.
Chaque case du tableau est numérotée, en partant de 0 : un tableau contenant 10 valeurs aura les
numéros de cases de 0 à 9 (on parle de l’indice de cellule).

5.1.1 DÉCLARATION

int[] monTableau = { 1995, 1996, 1997, 1998, 2000, 2001 };

0 1 2 3 4 5
1995 1996 1997 1998 2000 2001

Une autre déclaration (pour un tableau de chaîne vide par exemple) est la suivante :
String[] monTableau = new String[9];
String[] autreTableau = new String[9];

Ces deux tableaux contiendront donc 10 chaînes de caractères (l’index commence à 0 !).
int tailleTableau = autreTableau.length;

Enfin, il est possible d’utiliser des tableaux à plusieurs dimensions (comme pour la bataille navale) :
byte[,] monTableau = new byte[5,4];
int[,] autreTableau2D = {{1,2,3},{4,5,6},{7,8,9}};

Le premier tableau est une grille de 10x10 éléments tandis que le deuxième tableau contient 3x3
éléments. Il faut donc voir les tableaux à dimensions multiples comme des tableaux de tableau.

5.1.2 AFFECTATION

Dans l’exemple ci-dessus, la case autreTableau2D[0] contient le tableau {1, 2, 3}

Il existe des opérations très pratiques sur les tableaux, notamment le tri (.sort()) ou le remplissage
d’un tableau avec
var items = Enumerable.Repeat<bool>(true, 1000).ToArray();

David ROUMANET 01/02/2020 (v.101) 19

 BTS SIO SI4
Démarrage en C#

AutreTableau2D[0,1] = 666;
Console.writeLine("la case coordonnées 0,1 a pour valeur "+autreTableau[0,1]);

David ROUMANET 01/02/2020 (v.101) 20

 BTS SIO SI4
Démarrage en C#

6 LES ENTRÉES-SORTIES STANDARDS

En C#, les entrées et sorties concernent autant le mode console, que les fichiers et connexions.
Seule la gestion des interfaces graphiques est différente (utilise les notions d’événements). Les
notions utiles sont :
• Stream : un flux qui ne s’arrête pas, comme une émission en direct à la télévision
• Buffer : une zone mémoire pour ne pas perdre d’information (notamment si le flux n’est pas lu
suffisamment souvent).

6.1 MODE CONSOLE

Pour afficher et récupérer du texte, les méthodes de la classe System et C#.util sont nécessaires.

6.1.1 AFFICHAGE
Voici comment comprendre le code d’affichage suivant :
Console.writeLine("Bonjour !");

• System est la classe utilisée pour l’affichage sur une console. Il n’est pas nécessaire de la
déclarer si "using System" est placé en entête du programme.
• Console est l’objet dans cette classe, qui gère les sorties : ici, l’objet console est l’écran
principal de la console. Il existe un objet error qui permet de noter les erreurs. L’objet in est
utilisé pour récupérer les flux du clavier.
• WriteLine() est la méthode qui s’applique sur l’objet out : cette méthode envoie à cet objet les
données comprises entre ses parenthèses. .
Exemple :
Console.writeLine("Coco !"); // affichera 'Bonjour Coco !' sur la même ligne
Console.Error.WriteLine("Un problème"); // affichera 'Un problème'

6.1.2 SAISIE
La console est ouverte par défaut, ainsi que le flux en provenance du clavier (plus pratique qu’en
Java).
String reponse = Console.ReadLine(); // attend [Entrée] et stocke les données
ConsoleKeyInfo car = Console.ReadKey(); // attend l'appui d'une touche

David ROUMANET 01/02/2020 (v.101) 21

 BTS SIO SI4
Démarrage en C#

Le type pour récupérer le résultat de ReadKey() est un type objet. Nous verrons cela plus tard.

Il n’existe pas de lecture de clavier caractère par caractère qui ne serait pas bloquant.

6.1.3 DEBUG
Il existe une classe en C# qui permet d’afficher des informations dans la console du débogueur.
Pour cela, il faut activer la bibliothèque correspondante :
using System.Diagnostics ;

Ensuite, l’écriture vers cette console se fait par l’instruction suivante :

Debug.WriteLine("L’attribut resultat a pris la valeur "+resultat);

Enfin, pour visualiser la console dans Visual Studio, utilisez la séquence de touches CTRL+Alt+O

D’autres options sont disponibles pour une meilleure mise en forme, comme :
Debug.Indent() ;
Debug.Unindent() ;

L’intérêt de cette solution, est de ne pas polluer la console du programme principale, ou bien d’être
utilisable dans les programmes de type WinForm.

David ROUMANET 01/02/2020 (v.101) 22

 BTS SIO SI4
Démarrage en C#

6.2 FICHIERS
L’astuce ci-dessus nous amène à nous intéresser à la lecture et l’écriture de fichier.
Comme évoqué précédemment, pour C#, la plupart des périphériques sont considérés comme des
flux entrants et sortants. Cela signifie que si le flux n’est pas mémorisé, les données transmises sont
perdues (un peu comme une chaîne en direct : si vous êtes absent de l’écran, les informations sont
perdues).

Comme la plupart des périphériques acceptent les entrées et les sorties, cela multiplie par deux les
flux et buffets à déclarer.
Attention, la lecture d’un flux vide entraîne la génération d’une exception qui bloque l’exécution du programme.

Ainsi, la plupart du temps (et c’est aussi vrai en Java), il faudra ouvrir le flux et ouvrir un buffet :
1. Ouvrir le flux du fichier
2. Ouvrir le buffet du flux du fichier
3. Lire/Écrire dans le buffet
4. Fermer le buffet
5. Fermer le flux

Voyons cela avec un exemple, à la page suivante.

David ROUMANET 01/02/2020 (v.101) 23

 BTS SIO SI4
Démarrage en C#

Voici donc un exemple de code pour lire un fichier texte, à copier tel quel pour le moment :
using System;
using System.IO;
using System.Text;

namespace FileReadExample
{
class Program
{
static void Main(string[] args) {
FileStream monFlux = null; // Créer un objet flux (en direct)
StreamReader reader = null; // Créer un objet lecteur de flux (bufferise)
String fileContent = "";
try {
// Ouverture
monFlux = File.OpenRead(@"e:\test.txt");
reader = new StreamReader(monFlux, Encoding.UTF8);

// Lecture
Console.WriteLine("Votre fichier contient : ");
fileContent = reader.ReadToEnd();
Console.WriteLine(fileContent);
}
catch (Exception ex) {
Console.WriteLine("Erreur de lecture !"+ex.Message);
}
finally {
// Fermeture
if (reader != null) {
reader.Dispose(); // Fermer le buffer (libère sa mémoire)
}

if (monFlux != null) {
monFlux.Dispose(); // Fermer le fichier (libère le canal)
}
Console.Write("** Appuyez sur une touche **");
Console.ReadKey();
}
}
}
}

Le programme se déroule en 3 temps (ouverture, lecture, fermeture) et nécessite un fichier

texte présent sur le disque e:\ ! Vous pouvez donc créer un fichier texte ailleurs, en modifiant
l’emplacement dans le programme.

Pour écrire dans un fichier, il faut utiliser

monFlux = File.Open(@"c:\testwrite.txt", FileMode.Append);
Et pour écrire
writer.WriteLine("Hello World pour les fichiers :");

David ROUMANET 01/02/2020 (v.101) 24

 BTS SIO SI4
Démarrage en C#

Voici le code d’écriture :

using System;
using System.IO;

namespace FileReadExample
{
class Program
{
static void Main(string[] args) {
FileStream monFlux = null; // Créer un objet flux (en direct)
StreamWriter writer = null; // Créer un objet de flux (bufferise)

try {
// Ouverture
monFlux = File.Open(@"e:\testwrite.txt", FileMode.Append);
writer = new StreamWriter(monFlux);

// Lecture
Console.WriteLine("Écriture réussi dans e:\\testwrite.txt ");
writer.WriteLine("Hello World pour les fichiers :");
}
catch {
Console.WriteLine("Erreur d'écriture !");
}
finally {
// Fermeture
if (writer != null) {
writer.Dispose(); // Fermer le buffer (libère sa mémoire)
}

if (monFlux != null) {
monFlux.Dispose(); // Fermer le fichier (libère le canal)
}
Console.Write("** Appuyez sur une touche **");
Console.ReadKey();
}
}
}
}

et le résultat :

David ROUMANET 01/02/2020 (v.101) 25

 BTS SIO SI4
Démarrage en C#

7 EXERCICE

7.1 ENREGISTRER UN FICHIER CONTENANT UNE FICHE CONTACT

Votre programme doit demander quelques renseignements à l’utilisateur puis les enregistrer sous
forme de texte dans un fichier avec l’extension .txt

7.2 SOURCE FICHIER

https://openclassrooms.com/courses/apprenez-a-programmer-en-c-sur-net/lire-et-ecrire-dans-un-
fichier-2
http://www.java2s.com/Tutorials/CSharp/System.IO/File/C_File_OpenRead.htm

David ROUMANET 01/02/2020 (v.101) 26

 BTS SIO SI4
Démarrage en C#

8 BOUCLES ET CONDITIONS

Comme dans d’autres langages, C# propose un ensemble d’instructions pour créer des boucles et
permettre des choix à l’aide de conditions.

8.1 BOUCLES
Il existe 3 boucles connues (répétition, test avant de commencer la boucle et test en fin de boucle).

8.1.1 BOUCLE FOR OU FOREACH

La boucle for permet un comptage ou une énumération : elle s’écrit avec 3 paramètres séparés par
un point-virgule.
• Déclaration et initialisation de la variable de comptage
• Condition de sortie de boucle (tant que la condition n’est pas remplie, on reste)
• Choix de l’incrément (on peut aller de 2 en 2 ou bien partir dans le sens inverse en
décrémentant la variable)
for (int t=0 ; t < 7 ; t++) {
Console.writeLine("boucle N°"+t) ;
}

On peut aussi créer une boucle infinie comme ceci (sortie possible avec une instruction ‘break’) :
for (;;) {
Console.writeLine("ne s'arrête jamais... ahahah !") ;
}

Enfin, lorsqu’on a un tableau ou une liste d’objet, on peut la parcourir automatiquement (foreach)
int[] maTable1 = { 3, 14, 1, 59, 2, 65 };
Console.WriteLine("Taille de la table = " + maTable1.Length);
foreach (int cpt in maTable1) {
Console.Write(":" + cpt + " "); //cpt prend les valeurs 3 puis 14 puis 1, 59...
}

8.1.2 BOUCLE WHILE

Cette boucle classique propose un test en début de boucle. La boucle s’exécute tant que la
condition reste vraie. Si la condition est fausse dès le début, les instructions du bloc ne sont pas
exécutées.
int t=0;

David ROUMANET 01/02/2020 (v.101) 27

 BTS SIO SI4
Démarrage en C#

while (t < 10) {

// action à faire...
t++;
}

8.1.3 BOUCLE DO… WHILE

La condition se trouve à la fin de la boucle. Les instructions seront exécutées au moins une fois.
Cependant, contrairement à une boucle repeat… until(), la sortie de la boucle se fait lorsque la
condition est fausse (comme dans la boucle while classique).
do {
nbreHasard = (int) (Math.random() * 49 + 1);
} while (grilleLoto.contains(nbreHasard));

Il est possible de sortir d’une boucle sans que la condition ne soit modifiée, par l’utilisation de l’instruction break !

int t=0;
while (t < 10) {
if (t = 5) {
break;
}
t++;
}

8.2 CONDITIONS
Il y a deux types de conditions :
• les IF, ELSE IF, ELSE
• les SWITCH, CASE

8.2.1 CONDITIONS IF - ELSE

Le contenu du bloc est exécuté si l’ensemble de la condition est vrai : s’il y a plusieurs conditions
(dans la même parenthèse), elles doivent toutes être vraies. C’est le modèle le plus connu.
int testscore = 76;
char grade;
boolean work = true;

if (testscore >= 90 && work) {

grade = 'A';
} else if (testscore >= 80) {
grade = 'B';
} else if (testscore >= 70) {
grade = 'C';
} else if (testscore >= 60) {
grade = 'D';

David ROUMANET 01/02/2020 (v.101) 28

 BTS SIO SI4
Démarrage en C#

} else {
grade = 'F';
}
Console.writeLine("Grade = " + grade);

8.2.2 CONDITIONS SWITCH - CASE

Un peu moins visible, ce système de conditions est très structuré :
a = 1;
switch(a) {
case 0 :
Console.writeLine("nul"); break;
case 1 :
Console.writeLine("un"); break;
case 3 :
Console.writeLine("trois"); break;
}

Il y a cependant un impératif : ajouter une instruction ‘break’ avant chaque nouveau bloc ‘case’,
sinon dès qu’une condition est réalisée, tous les blocs suivants sont exécutés.
Essayez le programme précédent en enlevant les mots-clés ‘break’. Le résultat est-il cohérent ?

D’autre part, en C#, la gestion des plages (intervalles) n’est pas intuitive ! Le code le plus proche est
le suivant :
switch (num) {
case 1: case 2: case 3: case 4: case 5:
Console.writeLine("testing case 1 to 5");
break;
case 6: case 7: case 8: case 9: case 10:
Console.writeLine("testing case 6 to 10");
break;
default:
//
}

Les utilisateurs de Pascal et Purebasic seront surpris du manque de souplesse mais PHP et C#
fonctionnent de la même manière que C#. Enfin, il n’y a pas de switch/case en Python.

8.2.3 PORTÉE DE VARIABLES

La portée est une notion qui signifie simplement que plus un attribut est déclaré dans un bloc
supérieur, plus il est visible. Ce qui entraîne qu’un attribut déclaré dans une boucle, n’est visible que
dans cette boucle. Pour rappel, un bloc est généralement représenté entre { }.
for (int x=0; x < 10; x++) {
for (int y=0; y < 10; y++) {
Console.writeLine(x+"-"+y);

David ROUMANET 01/02/2020 (v.101) 29

 BTS SIO SI4
Démarrage en C#

int z = x*y;
}
Console.writeLine("Cette ligne entraine une erreur. Z = "+z);
}

David ROUMANET 01/02/2020 (v.101) 30

 BTS SIO SI4
Démarrage en C#

9 LES FONCTIONS

Les fonctions simplifient et fiabilisent le codage. En effet, effectuer les mêmes actions plusieurs fois
à la suite peut se faire dans une boucle. Effectuer les mêmes actions à des moments différents
nécessite de pouvoir exécuter le même morceau de code à plusieurs endroits du programme.
Voici les deux possibilités :
Avoir plusieurs fois du code identique Appeler plusieurs fois un seul code

Il est évident que la deuxième solution est plus fiable, plus élégance et moins encombrante.
Une fonction est donc un bout de code, utilisable à plusieurs endroits.

David ROUMANET 01/02/2020 (v.101) 31

 BTS SIO SI4
Démarrage en C#

9.1 CRÉATION D’UNE FONCTION

La syntaxe est la suivante :
portée static type nom(paramètre1, paramètre2…) { code et return valeur }
dit comme ceci, ce n’est pas clair mais en C#, cela donne :
public static int maximum(int nombreA, int nombreB) {
if (nombreA > nombreB) {
return nombreA ;
} else {
return nombreB ;
}
}

Le travail que va faire la fonction Maximum est d’évaluer quel est le nombre le plus grand et de
renvoyer sa valeur.
Évidemment, il est possible de ne pas avoir de paramètre et/ou de ne pas renvoyer de valeur. Une
fonction qui imprime sur l’imprimante par défaut serait (cas fictif) :
public void Imprimer() {
SortirImprimanteVeille() ;
LancerImpressionSpooler() ;
}

Cette fonction – qui appelle deux fonctions – ne renvoie pas de valeur, d’où le mot-clé ‘void’ qui
signifie "vide". L’appel à une fonction sans valeur de retour se fait comme pour la fonction
SortirImprimanteVeille() ou LancerImpressionSpooler() ;

9.2 APPEL D’UNE FONCTION

Pour utiliser les fonctions ainsi créées, il suffit de les appeler par leurs noms, comme nous le faisons
avec la fonction WriteLine() par exemple :
int A, B, Resultat ;
A = SaisirNombre() ;
B=SaisirNombre() ;
Resultat = Maximum(A, B) ;
Console.WriteLine(Resultat) ;

Comme Maximum() est une fonction, on peut l’utiliser partout :

monNombre = 100 ;
if (Maximum(25, monNombre) > 25) {
Console.WriteLine("Le maximum est : "+Maximum(25, monNombre)) ;
}

David ROUMANET 01/02/2020 (v.101) 32

 BTS SIO SI4
Démarrage en C#

9.3 ENTRAÎNEZ-VOUS : FONCTION SAISIRNOMBRE(INT MIN, INT MAX)

L’idée est de créer une fonction qui vérifie la saisie et n’accepte que des nombres entre nombreMin
et nombreMax. Tant que le nombre saisi n’est pas dans l’intervalle, on recommence la saisie.

Aide N°1 :
Il faut utiliser une boucle, dont on ne sort que si le résultat est un nombre.
Aide N°2 :
La conversion d’une chaîne de caractère en entier utilise la fonction C# existante :
monNombre = Convert.ToInt16(maChaine)
Aide N°3 :
Il faudra utiliser les exceptions (try… catch) au moment de la conversion (voir chapitre suivant de ce
livre)

Réponse
using System;

namespace SaisirNombre
{
class Program
{
public static Int32 SaisirNombre(Int32 min, Int32 max) {
String maChaine = "";
Int32 nombre=0;
do {
Console.WriteLine("Saisissez un nombre entre "+min+" et "+max);
maChaine = Console.ReadLine();
if (maChaine != "") {
try {
nombre = Convert.ToInt32(maChaine);
}
catch {
maChaine = "";
}
}
} while ((maChaine == "") | (nombre > max) | (nombre < min));
return nombre;
}

static void Main(string[] args) {

SaisirNombre(0, 10);
}
}
}

David ROUMANET 01/02/2020 (v.101) 33

 BTS SIO SI4
Démarrage en C#

10 LES EXCEPTIONS

C# fournit un moyen de contrôle des erreurs lors du déroulement des applications. Cette solution
se faisant au détriment de la performance et nécessitant du code supplémentaire, il est fréquent
que seules les parties sensibles du code soient protégées.

10.1 ARBORESCENCE DES EXCEPTIONS

Il existe plusieurs exceptions qui peuvent survenir par différentes situations :
• Lecture de données dans un fichier vide
• Lecture d’un fichier sur un média inexistant (retrait de clé USB par exemple)
• Division par zéro dans un calcul
• etc.
Une grande partie de ces erreurs sont habituelles et ne doivent pas bloquer le programme ou le
planter. C# peut donc décider d’avertir le programme du problème, et si le programmeur n’a rien
prévu, arrêter le programme.

Voici les classes des objets liés aux erreurs fréquentes (par exemple, la lecture d’un index de
tableau au-delà de la taille maximale du tableau générera une exception
"ArrayIndexOutOfBounds").

10.1.1 EXEMPLE DE CODE AVEC ERREUR

L’exemple le plus simple est la gestion d’une division par zéro.
public static void main(String[] args) {

David ROUMANET 01/02/2020 (v.101) 34

 BTS SIO SI4
Démarrage en C#

int a=20;
int b=0;
Console.writeLine(a+" divisé par "+b+" égal "+a/b);
}

Ce code entraînera l’erreur ArithmeticException :

Exception in thread "main" C#.lang.ArithmeticException: / by zero
at net.roumanet.Main.main(Main.C#:19)

Process finished with exit code 1

10.2 GESTION DES EXCEPTIONS RENCONTRÉES

La méthode est relativement simple et repose sur quelques instructions :
• try { … } : le bloc contenant le code contenant un risque d’exceptions
• catch { … } : un des blocs dédié au traitement des erreurs. Il peut y avoir plusieurs catch {}
• finally { … } : le bloc qui traite la sortie du code normal (try) ou des codes de traitements des
erreurs (pour fermer un fichier par exemple).

10.2.1 EXEMPLE DE CODE AVEC GESTION D’ERREUR

Dans le code précédent, il suffit d’ajouter try/catch sur l’erreur ArithmeticException pour pouvoir
afficher un message d’erreur plutôt qu’arrêter l’application.
public static void main(String[] args) {
// Préparation des attributs
int a=20;
int b=0;
try {
Console.writeLine(a + " divisé par " + b + " égal " + a / b);
}
catch (ArithmeticException e) {
Console.writeLine("le diviseur est nul : division par zéro impossible");
}
}

Ici, le programme ne traitera que cette erreur, mais il est possible de traiter chaque erreur (ou
exception) différemment : c’est l’ordre des catch {…} qui déterminera le premier traitement.
Il est également possible de récupérer le message d’erreur de l’exception, comme le montre le
code ci-dessous :
catch (Exception ex) {

David ROUMANET 01/02/2020 (v.101) 35

 BTS SIO SI4
Démarrage en C#

Console.WriteLine("Erreur ! " + ex.Message);

}

David ROUMANET 01/02/2020 (v.101) 36

 BTS SIO SI4
Démarrage en C#

11 LES INTERFACES GRAPHIQUES

Jusqu’à maintenant, nous avons programmé dans le mode console : il s’agit d’une interface
homme-machine austère mais facile à utiliser !
• L’ordinateur présente une information
• L’ordinateur attend une saisie… et ne fait rien d’autre
• Une fois la saisie effectuée, l’ordinateur continue le traitement

Cette programmation très séquentielle n’est pas celle utilisée sur les systèmes d’exploitation
graphiques.

11.1 FONCTIONNEMENT
Dans les OS modernes, c’est ce dernier qui gère tous les événements : le système "prête" des
ressources aux programmes. Une fenêtre, un champ de saisie, un bouton… ces éléments sont
dessinés et gérés par l’OS !
Dès lors, chaque clic, chaque action de l’utilisateur est enregistré par le système :

Lorsqu’il y a un événement qui concerne l’application, l’OS lui envoie le numéro de l’événement : le
programmeur décide s’il doit réagir à cet événement. L’avantage est qu’une application qui n’est
pas utilisée ne consommera pas de puissance à sa propre surveillance.

David ROUMANET 01/02/2020 (v.101) 37

 BTS SIO SI4
Démarrage en C#

En C#, Visual Studio nous propose un éditeur graphique de fenêtre et masque une partie du
codage.

11.2 VISUAL STUDIO ET PROJET WINDOWS FORMS

Dans Visual Studio, créez un nouveau projet de type Windows Forms Application (Net Framework).
L’IDE s’affiche avec 3 parties importantes :

Voici l’utilité des différentes parties :

• La zone bleue affiche la forme sur laquelle vous travaillez : grâce aux poignées de sélection,
vous pouvez redimensionner tous les éléments.
• La zone verte contient les propriétés de l’élément sélectionné : c’est ici qu’on peut renommer
un champ, changer sa couleur, bloquer ses propriétés (éditable ou non, etc.
◦ Dans la zone verte, l’icône verte représentant un éclair permet d’éditer les actions à
effectuer en fonction des événements. Un clic, un touche enfoncé, un changement…
◦ Pour revenir aux propriétés statiques de l’élément, il faut cliquer sur l’icône ayant une clef à
molette (champ bleu dans la zone verte sur l’image).

David ROUMANET 01/02/2020 (v.101) 38

 BTS SIO SI4
Démarrage en C#

• La zone rouge contient la boite à outils : tous les éléments utilisables dans la fenêtre peuvent
être sélectionnés et placés sur celle-ci. Pour afficher la boite à outils : CTRL+Alt+X

11.2.1 LES FICHIERS

La création d’une application en mode console générait un seul fichier, Program.cs.
La création d’une application en mode fenêtre génère trois fichiers :
• Program.cs qui reste le fichier principal. Cependant, la fonction Main() est désormais
différente.
• Form1.cs (ou MainForm.cs sous SharpDevelop). Ce fichier contient les actions et fonctions
que le programmeur peut gérer et modifier.
• Form1.Designer.cs (ou MainForm.Designer.cs) : ce fichier contient les composants qui sont
inclus dans la fenêtre : positions, tailles, propriétés y sont définis. Il est préférable de ne pas
modifier manuellement ce fichier.

Il faut comprendre la philosophie d’usage : et pour cela, parler légèrement du modèle MVC. Il s’agit d’un modèle qui
permet de simplifier le développement, en séparant la vue (les fenêtres, l’affichage), le contrôleur (les interactions de
l’utilisateur : clic, saisie au clavier, déplacement de souris…) et le modèle de stockage des données (une base, un fichier,
la mémoire…). MVC signifie Modèle – Vue – Contrôleur.

11.2.2 LES MORCEAUX DE CODE

Voici quelques explications sur le contenu de chaque fichier. Tout ne sera pas expliqué ici, mais
cette partie devrait suffire pour vous permettre de créer des applications graphiques.

11.2.2.1 PROGRAM.CS
Il contient l’appel de la fenêtre graphique. Comme c’est une programmation événementielle, le
programme devient multi-tâche (il accepte notamment d’être géré par le système).
Visual Studio Sharp Develop
[STAThread] [STAThread]
static void Main() { private static void Main(string[] args) {
Application.EnableVisualStyles(); Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false); Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1()); Application.Run(new MainForm());
} }

La ligne importante est :

Application.Run(new Form1()) ;

David ROUMANET 01/02/2020 (v.101) 39

 BTS SIO SI4
Démarrage en C#

"Run" indique un fonctionnement en thread et "new Form1()" la demande de création de la fenêtre

au système.

11.2.2.2 FORM.DESIGNER.CS
C’est le fichier qui contient la construction de la fenêtre. On y trouve notamment la fonction (on
dira "méthode") qui génère les composants de manière procédurale.
En effet, si vous devez créer 40 composants identiques (imaginez une application contenant un
champ par jour de la semaine), dessiner ces composants manuellement est fastidieux. La syntaxe
utilisée ici, permettra de générer dans une méthode conçue par le développeur, les composants
répétitifs.
private void InitializeComponent() {
this.textBox1 = new System.Windows.Forms.TextBox();
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(32, 29);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(246, 20);
this.textBox1.TabIndex = 0;
//
// button1
//
this.button1.Location = new System.Drawing.Point(215, 70);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(62, 31);
this.button1.TabIndex = 1;
this.button1.Text = "Cliquez ici";
this.button1.UseVisualStyleBackColor = true;
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(339, 131);
this.Controls.Add(this.button1);
this.Controls.Add(this.textBox1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout();

Notez que les attributs des composants sont suivis par les propriétés puis les valeurs :
this.button1.Text = "textBox1";
Cette ligne signifie que pour le composant button1, on place la valeur "Cliquez ici" dans la propriété
"Text".

David ROUMANET 01/02/2020 (v.101) 40

 BTS SIO SI4
Démarrage en C#

11.2.2.3 FORM1.CS
C’est ce fichier qui contiendra les interactions entre l’utilisateur et l’interface du programme. Ainsi,
les lignes suivantes méritent d’être expliquées :
public Form1() {
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e) {

MessageBox.Show("Bravo, vous avez cliqué sur le bouton !");
}

La méthode "Form1()" est publique, donc visible de partout. Elle ne contient qu’une ligne qui
appelle la construction de la fenêtre, dans le fichier Form1.Designer.cs.
La méthode "button1_Click()" correspond aux actions qui seront faites lorsque l’événement
correspondant est appelé. Ici, on affiche une simple boite d’alerte. Notez cependant, que cette
méthode reçoit deux paramètres : l’appelant (sender) et le type d’événement (e).
en effet, lors de l’initialisation des composants, on indique au système (dans le fichier
Form1.Designer.cs) que le programme surveillera les événements qui touchent à ce bouton :
this.button1.Click += new System.EventHandler(this.button1_Click);

Ces informations dépassent le niveau du module SI4 : il s’agit cependant d’une culture générale pour comprendre
comment fonctionne les applications dans les systèmes graphiques fenêtrés.

11.3 CE QUI FAUT RETENIR EN PROGRAMMATION ÉVÉNEMENTIELLE

L’IDE permet de générer automatiquement les formes (fenêtres) et composants nécessaires à vos
applications.
Le déroulement de l’application n’est plus linéaire : l’utilisateur peut cliquer sur n’importe quel
composant et ce, dans le désordre. En tant que programmeur, vous devez donc vous assurer que
les opérations à réaliser sont possibles au moment de l’appel à vos fonctions.
L’OS met à la disposition du programmeur des bibliothèques de composants et leurs
comportements associés : il faut donc connaître les composants principaux 1 : textBox, button,
checkBox, listBox, …

1 https://www.codeproject.com/Articles/1465/Beginning-C-Chapter-Using-Windows-Form-Controls

David ROUMANET 01/02/2020 (v.101) 41

 BTS SIO SI4
Démarrage en C#

12 LES OBJETS

En C#, les objets s’utilisent un peu comme des "super" variables.

Un objet en C#, correspond à un ensemble de variables et des fonctions intégrées. Grâce à une
notion importante appelé encapsulation, il est possible de n’accéder à ces variables qu’au travers
de ces fonctions.
Ainsi, une classe est donc un bloc autonome, et les objets créés à l’aide de cette classe ne peuvent
pas être mis en "pièces détachées".

12.1 VOCABULAIRE
Le langage orienté objet propose un vocabulaire à connaître
impérativement. Ci-contre, la représentation symbolique d’une classe.
Une classe est constituée de membres :
• les attributs : ce sont les variables de la classe. Sauf s’ils sont publics,
les attributs ne sont pas visibles depuis une autre classe (étrangère).
• Les méthodes : ce sont les fonctions ou procédures de la classe. Elles
aussi peuvent être publiques ou privées.

Une classe n’est qu’un patron, un plan d’objet : il faut construire les objets à partir de ce plan, en
objet le terme utilisé : instancier.
Pour instancier une classe, on utilise une méthode de la classe particulière, qui porte le nom de la
classe, et qu’on appelle un constructeur.

12.2 REPRÉSENTATION
Voici un exemple graphique :

La
classe
Chat

David ROUMANET 01/02/2020 (v.101) 42

 BTS SIO SI4
Démarrage en C#

contient les attributs privés couleurPelage, nom et age (un signe – les précède).
Elle contient les méthodes publiques (signe +) permettant de modifier ou lire les attributs : cela
signifie qu’il n’est possible de modifier ces attributs que par ces méthodes, ce qui est très
sécurisant.

12.2.1 INSTANCIATION

Pour créer le chat Félix, il suffit d’instancier la classe Chat et de stocker le résultat dans une
"variable" de type Chat (ce n’est pas un entier, une chaîne… c’est un chat).
La syntaxe d’instanciation est la suivante :
Chat felix = new Chat();

felix.changerNom("Felix");
felix.changerAge(5);

le mot-clé new indique à C# de construire un objet, mais comme pour une maison, l’objet est
initialement vide.
Notez qu’il n’est pas nécessaire de nommer l’objet avec le véritable nom du chat.
Chat chatRoumanet = new Chat() ;
chatRoumanet.changerNom("Pirouette") ;
…

A noter : si le constructeur de la classe n’est pas déclaré explicitement, C# va le créer automatiquement, avec tous les
attributs par défaut.

Astuce : il est possible d’avoir plusieurs constructeurs, à la condition que le nombre d’arguments
soit différents pour chaque constructeur et qu’il soit public (donc visible par tous).
Le mot-clé this permet de préciser à C# qu’il s’agit de l’attribut de l’objet en cours de création,
permettant de ne pas mélanger avec le nom de l’argument transmis :

public Chat() {}

public Chat(String nom) {

this.nom = nom; //this.nom correspond à l'objet, nom à l'argument méthode
}

public Chat(int age, String nomChoisi) {

this.age = age;
this.nom = nomChoisi ;
}

David ROUMANET 01/02/2020 (v.101) 43

 BTS SIO SI4
Démarrage en C#

12.2.2 ACCESSEURS ET MUTATEURS

Les méthodes qui permettent de lire et modifier les attributs privés dans la classe, sont appelées
des accesseurs et mutateurs. En anglais, les termes pour…
• les accesseurs qui permettent de lire : les getters
• les mutateurs qui permettent de modifier : les setters
Dans la classe Chat, Les méthodes voirAge() est un accesseur et changerAge(int age) est un
mutateur.

12.2.3 PORTÉES ET MODIFICATEURS

Plusieurs fois présenté pour certaines, les portées servent à protéger les attributs et les méthodes.
Les 3 modificateurs importants pour le moment sont private, public et static.
Dans le détail,

12.2.3.1 POUR LES CLASSES

static La classe ne peut pas être instanciée : elle est unique et définie une seule fois en mémoire.
abstract La classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite.
Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui hérite de cette
classe et qui implémente les méthodes nécessaires.
final La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite.
(sécurité) Les classes déclarées final ne peuvent donc pas avoir de classes filles.
private La classe n'est accessible qu'à partir du fichier où elle est définie.
(accessibilité)
public La classe est accessible partout. (C'est la valeur par défaut, mais il faut la préciser pour que la classe soit
(accessibilité) accessible en dehors de son package.)

12.2.3.2 POUR LES MÉTHODES

static La méthode static déclarée statique ne peut agir que sur les attributs de la classe et pas sur les attributs
des instances. La méthode main() est une méthode statique car il ne peut y avoir qu’un point de
démarrage du programme.
Abstract La méthode n’a pas de code. En cas d’héritage par une classe fille, celle-ci devra définir sa propre
méthode.
private La méthode n'est accessible qu'à l’intérieur de la classe où elle est définie.
(accessibilité)
public La méthode est accessible partout.
(accessibilité)

David ROUMANET 01/02/2020 (v.101) 44

 BTS SIO SI4
Démarrage en C#

12.2.3.3 POUR LES ATTRIBUTS

static L’attribut est unique pour l’ensemble des instances. Il est généralement utilisé pour un comptage
final L’attribut est une constante : il ne peut être modifié après sa première initialisation
private L’attribut n'est accessible qu'à l’intérieur de la classe où elle est définie.
(accessibilité)
Protected L’attribut est accessible par sa classe mais aussi les classes filles (héritage)
(accessibilité)
public L’attribut est accessible partout.
(accessibilité) Exemple : maVoiture.puissance = 215;

12.2.4 ANALYSE D’UN PROGRAMME

Le premier programme saisie (HelloWorld) peut donc maintenant être totalement analysé :

/* voici un exemple de code */

public class HelloWorld {
public static void main(String[] args) {
// Prints "Hello, World" to the terminal window.
Console.writeLine("Hello, World");
}
}

La classe publique HelloWorld n’a pas d’attribut.

Elle ne contient qu’une méthode publique dont voici les arguments :
public Il s’agit d’une méthode publique, utilisable depuis une autre classe
static Cette méthode n’est pas instanciable : c’est toujours le cas pour main()
qui est la méthode de lancement des applications (il ne peut en exister
qu’une seule officielle par programme)
void La méthode ne renvoie aucun argument (le type void signifie ‘vide’)
main Le nom de la méthode
String[] args La méthode accepte des arguments en entrée : un tableau de chaîne de
caractères.

David ROUMANET 01/02/2020 (v.101) 45

 BTS SIO SI4
Démarrage en C#

12.3 RÉSUMÉ
Création d’une classe Déclaration d’un objet de la classe

(il
s’agit d’une réservation d’espace)

Instanciation d’un objet Modification d’un attribut public/privé

Modification d’un attribut privé (mutateur) Copie de la référence

David ROUMANET 01/02/2020 (v.101) 46

 BTS SIO SI4
Démarrage en C#

12.4 HÉRITAGE
L’intérêt majeur de la programmation objet est probablement l’héritage : cette notion permet
en effet de profiter des propriétés d’une classe existante et de pouvoir étendre ses capacités.

12.4.1 EXEMPLE
Une clinique vétérinaire qui doit enregistrer des chats et des chiens pourrait avoir deux
classes, comme dans l’image suivante :

Cependant, on constate que de nombreux éléments sont communs, hormis la particularité

des chats pour griffer et celle des chiens pour mordre.
L’héritage permet de simplifier le développement en ne créant qu’une seule fois les membres
(attributs et méthodes) communs et en créant les classes propres aux deux espèces.

12.4.2 DÉCLARATION
La déclaration d’un héritage de classe se fait par le symbole ' :' comme ci-dessous :
public class Chat : Animal {
public void griffer() {
Console.writeLine("Griffé !") ;
}
}
public class Chien : Animal {
public void mordre() {
Console.writeLine("Mordu !") ;
}
}

Contrairement au C++, En C# (et même en Java) une classe ne peut hériter que d’une seule classe.

David ROUMANET 01/02/2020 (v.101) 47

 BTS SIO SI4
Démarrage en C#

12.4.3 UTILISATION
Une fois déclarée, la classe s’utilise normalement.
Chat monChat = new Chat();
Chien monChien = new Chien();
Animal maTortue = new Animal();

12.4.4 EXEMPLE DE CODAGE (TD À REPRODUIRE)

Dans la pratique, il n’est pas possible de placer les classes filles dans le même fichier que la classe
mère. Il faut donc créer un fichier par classe.
Voici la classe mère Animal (nommer le fichier Animal.cs) :
/**
* Created by david on 09/04/2017.
*/
using System;

namespace Animal
{
public class Animal
{
protected String nom;
protected Int16 poids;
protected DateTime naissance;

// constructeur explicite pour créer et affecter les attributs en même temps

public Animal(String nom, Int16 poids, DateTime dnaissance) {
this.nom = nom;
this.poids = poids;
this.naissance = dnaissance;
}
public Animal() {
this.nom = "(inconnu)";
this.poids = 0;
this.naissance = DateTime.Now.Date;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public DateTime getNaissance() {
return naissance;
}
public void setNaissance(DateTime naissance) {
this.naissance = naissance;
}
static void Main(string[] args) {
}
}
}

David ROUMANET 01/02/2020 (v.101) 48

 BTS SIO SI4
Démarrage en C#

Toujours dans le même namespace (package), clic droit, Ajouter ► Class

Il suffit d’écrire les quelques
lignes ci-contre et de valider
que l’IDE présente les
attributs de la classe mère
lorsque vous créez le
constructeur de la classe.

Ici, naissance, nom et poids (ordre alphabétique) appartiennent bien à la classe Animal dans le
fichier Animal.cs.
La classe Chat étend la classe Animal en ajoutant le miaulement (méthode Miaule()) :
using System;

namespace Animal
{
class Chat : Animal
{
public Chat() {
this.nom = "Minou inconnu";
}
public String Miaule() {
return "Miaou";
}
}
}

Enfin, éditer la méthode main() de votre programme comme suit :

using System;

namespace Animal
{

public static void main(String[] args) {

// Préparation des attributs
Chat leMinou = new Chat();
Console.writeLine("Le chat ayant pour étiquette 'leMinou' s'appelle
"+leMinou.nom);
}
}

David ROUMANET 01/02/2020 (v.101) 49

 BTS SIO SI4
Démarrage en C#

Le résultat sera :

12.4.5 EXERCICE
Finissez la classe Chat en ajoutant la méthode griffer(). Cette méthode contient un tirage au hasard
entre 0 et 0.999 et affichera
"le-nom-du-chat a essayé de vous griffer" si le tirage est supérieur à 0.8, sinon
"le-nom-du-chat vous aime bien et ne vous griffe pas".

Créez également la classe Chien en y intégrant la méthode mordre() ayant un comportement

similaire que la méthode griffer().
Pour validation auprès du professeur, envoyez seulement le contenu du répertoire ‘src’ dans un
fichier ZIP.

David ROUMANET 01/02/2020 (v.101) 50

 BTS SIO SI4
Démarrage en C#

13 LES CLASSES ABSTRAITES ET INTERFACES

Les classes sont des modèles pour créer des objets. Coder une classe ne permet pas de créer des
objets tant que l’on instancie pas la classe (xxx = new Class()) et que la classe ne contient pas de
constructeur.
Il est pourtant possible de créer des modèles de classe ou des modèles de méthodes. L’utilité est de
s’assurer que les utilisateurs de ces modèles proposeront bien des classes ayant des critères
communs, par exemple :
• Il existe plusieurs formes géométriques (en deux dimensions), pour chacune on veut obtenir la
surface et le périmètre. Les formules de calculs étant différentes, il faut fixer 2 méthodes Aire()
et Perimetre() que chaque codeur de forme devra utiliser
• Le remplissage d’une forme est commun à toutes les formes. Il n’est pas nécessaire que
chaque codeur ré-écrive une méthode de remplissage.

13.1 CLASSE ABSTRAITE

Les classes abstraites sont une solution à l’exemple ci-dessus : le développeur de la classe ‘Forme’
va créer les méthodes communes et laisser "vide" les méthodes de calculs. On dit que
l’implémentation est partielle.
namespace ClassesAbstraites
{
public abstract class Formes {
protected int couleurForme;
protected float aireForme;
protected float perimetreForme;

public Formes() {
couleurForme = 0;
aireForme = 0;
}
public void Remplissage(int color) {
this.couleurForme = color;
}

public abstract void Aire(float[] valeurCalcul);

public abstract void Perimetre(float[] valeurCalcul);
}
// voici comment utiliser la classe abstraite
public class Carre : Formes {
public override void Aire(float[] valeurCalcul) {
this.aireForme = valeurCalcul[0] * valeurCalcul[0];
}
public override void Perimetre(float[] valeurCalcul) {
this.aireForme = valeurCalcul[0] * 4;

David ROUMANET 01/02/2020 (v.101) 51

 BTS SIO SI4
Démarrage en C#

}
}
}

L’exemple donné montre comment la classe ‘Carre’ implémente la classe ‘Formes’ :

• Dans la classe Formes ► Les méthodes Aire() et Perimetre() sont déclarées comme étant
abstraites, grâce au mot-clé ‘abstract’.
• Dans la classe Carre ► On écrit les méthodes Aire() et Perimetre() en recouvrant la définition
d’origine, grâce au mot-clé ‘override’.

13.1.1 EXERCICE
Ajoutez une classe ‘Disque’ dont on calculera :
• le périmètre par la formule 2 * PI * valeurCalcul[0]
• l’aire par la formule PI * r²
Pour rappel, valeurCalcul est un tableau mais pour un disque, on n’utilise que le premier élément pour y placer le
rayon.

Le calcul d’un nombre élevé au carré (x²) se fait avec Math.Pow(x, 2)

13.1.2 EXERCICE
Ajoutez une classe ‘Rectangle’ dont on calculera :
• le périmètre par la formule (valeurCalcul[0] + valeurCalcul[1])* 2 (P=(a+b)*2)
• l’aire par la formule valeurCalcul[0] * valeurCalcul[1] (A = a * b)

13.2 LES INTERFACES

Les interfaces vont plus loin : c’est un contrat que le codeur s’engage à respecter.
Chaque attribut et chaque méthode devra être implémenté en utilisant les mêmes noms.
La classe aura un nom qui commencera conventionnellement par un ‘i’ majuscule. Le mot-clé ‘class’
est remplacé par ‘interface’. Enfin, comme il s’agit d’un contrat public, les éléments sont toujours
publics. Exemple :

interface IAnimal {
string Name { get; }
void Move();
}

David ROUMANET 01/02/2020 (v.101) 52

 BTS SIO SI4
Démarrage en C#

Ici, l’interface ‘Ianimal’ contient un atribut (public) ‘Name’ et une méthode (publique) Move().
Pour utiliser l’interface, il faut écrire le code suivant :
class Dog : IAnimal
{
private string m_name;
// On implémente la propriété Name accessible en lecture.
public string Name
{
get { return m_name; }
}

public Dog(string name) {

m_name = name;
}

// On implémente la méthode Move.

public void Move() {
Console.WriteLine("{0} bouge.", m_name);
}
}

Cet exemple est inspiré de celui donné sur https://openclassrooms.com/courses/apprenez-a-

programmer-en-c-sur-net/les-interfaces-6

On crée notre propre attribut de stockage du nom en privé. Les utilisateurs de la classe ‘Dog’ ne
connaîtront jamais cet attribut et utiliseront ‘Name’ à la place : cela garantit le même usage par
tous !
Notez que la modification du nom du chien ne se fera qu’à l’instanciation de la classe : une fois nommé, le chien ne
changera plus de nom.

L’implémentation de la méthode Move() est similaire à une classe abstraite mais n’utilise pas
‘override’. L’oubli de cette implémentation donne lieu à un message clair du compilateur :

Enfin, voici comment utiliser la classe ‘Dog’ :

class Program
{
public static void Main() {
IAnimal chienTintin = new Dog("Milou");
chienTintin.Move();
}
}

L’avantage principal est qu’une classe peut hériter de plusieurs interfaces (alors qu’une classe ne
peut hériter que d’une seule classe).

David ROUMANET 01/02/2020 (v.101) 53

 BTS SIO SI4
Démarrage en C#

14 ANNEXES

David ROUMANET 01/02/2020 (v.101) 54